using new

comment from a book: “ With dynamic memory allocation, however, the compiler doesn’t know how much storage you’re going to need, and it doesn’t know the lifetime of that storage. That is, the storage doesn’t get cleaned up automatically. ”

I don’t fully understand above statement.
If I say:

Code:

---

new unsigned char[100];

---

Does that mean the compiler do not know that I want 100 new bytes?
And what’s the meaning of that the compiler doesn’t know the lifetime of that new storage? If I create a variable using new inside a function, isn't it's life time is that function?
Please explain.

Thanks a lot.

It just means the compiler doesn't know how much memory you're going to need any more than it knows the initial value of a variable. You have to tell it both values.

The scope of a variable declared with static memory is the length of the function it is declared in or throughout the program if it's global. Not so with dynamic memory. With dynamic memory the memory and the value stored at that address are available until you free the memory manually as long as you pass the variable back and forth between functions.

Normally, when you declare a variable, it is created from the stack, therefore a) the size is known at compile-time and b) the compiler will generate the code to properly destroy it (remove it from the stack) when the variable goes out of scope. On the other hand, with dynamic allocation, the memory does *not* come from the stack, but from the heap (the pointer to the memory *does* come drom the stack, of course, and will follow normal scoping rules, but what we're talking about here is the memory it *points* to). The heap is really just another area of ram outside of your program's memory space. When you call malloc, or new, the OS's memory manager finds a block from the heap and returns a pointer to it (or NULL if unavailable). Thus, you have to manage the memory yourself, ie: free it when you're done with it.

It's much clear now. Thanks.

Actually, the compiler does "know" how much memory to allocate with char[100]. But, wiith dynamic allocation you can say:

new unsigned char[x]; // Now, the compiler might not know what x is.

You cannot do that without using dynamic allocation (unless x is a constant/macro defined at compile-time.)

Also, that statement could be in a loop, and the compiler might not know how many times you are going to execute the loop!!!

For example, if you need to add a new name to a database... you might not know how many names the database will to hold when you write the program.

Perhaps the book should have said:
...the compiler doesn’t need to know how much storage...

Or,
...the compiler doesn’t care how much storage...