3

I'm a bit confused about the difference between when I just declare a variable such as:

int n;

and dynamically assigning memory to a variable using "new" such as:

int m = new int;

I noticed just from working on a simple linked list project that when I'm inserting a new value in the form of an node object, I have to dynamically create a new node object and append the desired value to it and then link it to the rest of my list. However.. in the same function, I could just define another node object, ex. NodeType *N. and traverse my list using this pointer. My question is.. when we just declare a variable, does memory not get assigned right away.. or what's the difference?

Thank you!

jerbotron
  • 307
  • 1
  • 4
  • 14
  • 1
    I [answered this before](http://stackoverflow.com/questions/8839943/why-does-the-use-of-new-cause-memory-leaks-in-c/8840302#8840302). – R. Martinho Fernandes May 30 '12 at 20:05
  • 3
    The difference? One works, and the other gives you a compiler error. (`int*` is not implicitly convertible to `int`.) – cHao May 30 '12 at 20:06
  • 2
    @R.MartinhoFernandes This seems like a different question. – Pubby May 30 '12 at 20:06
  • @Cicada you must be new here. – Luchian Grigore May 30 '12 at 20:10
  • 2
    Not really a duplicate... Not at all... – Luchian Grigore May 30 '12 at 20:14
  • @Cicada That pdf would be much much better if had an actual explanation. – Pubby May 30 '12 at 20:14
  • 1
    Is it me, or does the bottom paragraph of the question have nothing to do with the first two code examples? – Mr Lister May 30 '12 at 20:22
  • yeah.. I realize now that my question was poorly worded. my questions did originally arise regarding defining pointers but i tried to make it easier by using normal variables not realizing it's a complete different story. But anyhow, i think @LuchianGrigore answered my question prefectly! and thanks for everyone else's input! – jerbotron May 30 '12 at 20:32

3 Answers3

6

Prefer automatic storage allocated variables when possible:

int n;

over 

int* m = new int; // note pointer

The reason dynamic allocation is prefered in your case is the way the linked list is defined. I.e. each node contains a pointer to a next node (probably). Because the nodes must exist beyond the point where they are created, they are dynamically allocated.

NodeType *N. and traverse my list using this pointer

Yes, you could do that. But note that this is just a pointer declaration. You have to assign it to something meaningful to actually use it.

My question is.. when we just declare a variable, does memory not get assigned right away.. or what's the difference?

Actually, both cases are definitions, not just declarations.

int n;

creates an un-initialized int with automatic storage;

int* n;

creates a pointer to an int. It's dangling, it doesn't point to a valid memory location.

int* n = new int;

creates a pointer and initializes it to a valid memory location containing an uninitialized int.

int* n = new int();

creates a pointer and initializes it to a valid memory location containing a value-initialized int (i.e. 0).

Luchian Grigore
  • 253,575
  • 64
  • 457
  • 625
1
int m = new int;

is actually incorrect. new returns a pointer to the memory its created. It should be 

int *m = new int;

And even better:

int *m = new int();

which sets the initial value of the variable pointed to by m = 0.

Also, in regards to your question, big objects are typically created with pointers to eliminate large copy operations when they are passed from function to function by value. They also are used when the life of the variable is needed to be longer than the scope of the functions.

However, for variables used in the scope of a function, and are not useful anywhere else, automatic memory should be used

int m;
Drise
  • 4,310
  • 5
  • 41
  • 66
  • 2
    "Also, in regards to your question, big objects are typically created with pointers to eliminate large copy operations when they are passed from function to function." this is incorrect, you can pass by reference. There are different reasons. – Luchian Grigore May 30 '12 at 20:11
  • 1
    I typically won't pass a pointer unless i'm handing off "ownership" of the object. (And even then, it'd generally be a smart-pointer type.) For pretty much any other case, when dealing with my own code, i'd pass by reference. Besides having clearly "not yours" semantics (to me anyway), and making it harder to accidentally squirrel away a pointer that could become invalid at any moment, it also makes for code less cluttered with `*` and `->` and `&`. – cHao May 30 '12 at 20:15
  • mm, just another quick question. What does it mean to pass by reference? i'm guessing that's different than passing by pointers like (*head, **List, etc)? – jerbotron May 30 '12 at 20:33
  • By reference passes the address to the variable, not the variable itself. – Drise May 30 '12 at 20:35
  • 1
    You can *almost* think of it as passing the variable. Generally, behind the scenes, it's a pointer to the memory occupied by the variable, that pretends to be what it's pointed at. In most cases, it does its job so well that you wouldn't know it's not the real thing. The main differences between references and plain old variables are (1) polymorphism works with references, and (2) passing by reference lets the callee change the caller's version of the variable. It's basically most of the power of a pointer to a single object, but without all that plumbing sticking up in the living room. – cHao May 31 '12 at 13:39
  • 1
    BTW, by default, you don't pass a variable to a function. Pass-by-value, the default, is actually passing the variable's *value* -- that is, a copy of the original. The distinction becomes pretty important once references get involved, because pass-by-reference is designed to act like passing the variable itself. – cHao May 31 '12 at 13:53
  • @chao Thanks for clarifying that with such detail. – Drise May 31 '12 at 17:29
1

The difference is that automatic storage can only be used when the compiler can determine at compile time how much memory is needed and how long it will be needed for. Typically automatic variables will be allocated on the stack.

Whereas for memory that is allocated dynamically the programmer is responsible for keeping track of this information. This is typically allocated on the heap. Using heap memory will typically have greater overhead for a variety of reasons, and there is a risk of memory leak where you allocate heap memory but never free it.

In the example you described of a linked list, it's unlikely that you know the length of the list at compile time (if you did then you could just use a static array), so that is why you will need to manage the memory explicitly rather than letting the compiler take care of memory management automatically. But the pointer that you use to traverse the list is not needed after the function returns, so that is why it can be managed automatically by the compiler.

Gabriel Southern
  • 9,602
  • 12
  • 56
  • 95