Teach Yourself Borland C++ in 14 Days - portal

Up to Your Neck in C++
In this case you can now use the pointer, ptr, just as you would the array name itself. I can
hear you wondering, though: “But why would you want to?” The truth is that in this example
there is no real benefit to using a pointer. The real benefit of pointers is when it comes to
creating objects dynamically in memory. In that case, a pointer is necessary to access the
object. I really can’t go on with this discussion, though, until I digress a moment and talk
about the two ways you can create variables and objects.
Local Versus Dynamic Memory Usage
So far all my sample programs have used local allocation of objects—that is, the memory
required for a variable or object is obtained from the program’s stack.
Local allocation means that the memory required for a variable or object is obtained
from the program’s stack.
NEW TERM
NEW TERM
The stack is an area of working memory set aside by the program when the program
starts.
Any memory the program needs for things such as local variables, function calls, and so on
is taken from the stack. This memory is allocated as needed and then freed when it is no longer
needed. Usually this happens when the program enters a function or other local code block.
Memory for any local variables the function uses is allocated when the function is entered.
When the function returns, all of the memory allocated for the function’s use is freed. It all
happens for you automatically; you don’t have to give any thought to how or if the memory
is freed.
Local allocation has its good points and its bad points. On the plus side, memory can be
allocated from the stack very quickly. The downside is that the stack is of a fixed size and
cannot be changed as the program runs. If your program runs out of stack space, weird things
start to happen. Your program might just crash, it might start behaving oddly, or it might
seem to perform normally but crash when the program terminates. This is less of a problem
in the 32-bit world than it is in 16-bit programming, but it’s still a consideration.
For things like variables of the built-in data types and small arrays, there is no point in doing
anything other than local allocation. But if you are going to be using large arrays, structures,
or classes, you will probably want to use dynamic allocation from the heap. This amounts to
your free physical RAM plus all of your free hard disk space. In other words, you could easily
have 100MB of heap memory available on a typical Windows system. The good news here
is that you have virtually unlimited memory available for your programs. The bad news is that
memory allocated dynamically requires some additional overhead, and as such is just a
smidgen slower than memory allocated from the stack. In most programs the extra overhead
is not noticed in the least. An additional drawback of dynamic allocation is that it requires
more from the programmer. Not a lot more, mind you, but a little.
69
3