DYNAMIC
MEMORY ALLOCATION:
Memory in
C++ program is divided into two parts:
Ø The stack: All variables declared inside the
function will take up memory from the
stack.
Ø The heap: This is unused memory of the
program and can be used to allocate the memory
dynamically when program runs.
1. Many
times, we are not aware in advance how much memory you will need to store
particular information in a defined variable and the size of required memory
can be determined at run time.
2. We can
allocate memory at run time within the heap for the variable of a given type
using a
special operator in C++ which returns the address of the space allocated. This
operator is called new operator.
If we are
not in need of dynamically allocated memory anymore, you can use delete operator, which de-allocates
memory previously allocated by new operator.
The new and delete operators:
There is
following generic syntax to use new
operator to allocate memory dynamically for any data-type.
new data-type;
Here, data-type could be any built-in data
type including an array or any user defined data types include class or
structure. Let us start with built-in data types. For example we can define a
pointer to type double and then request that the memory be allocated at execution
time.
We can do
this using the new operator with the
following statements: double* pvalue =
NULL; // Pointer initialized with null
pvalue = new double; // Request memory for the variable
The
memory may not have been allocated successfully, if the free store had been
used up. So it is good practice to check if new operator is returning NULL
pointer and take appropriate action as below:
double*
pvalue = NULL;
if(
!(pvalue = new double ))
{
cout
<< "Error: out of memory." <<endl; exit(1); }
Example:
#include
<iostream.h>
int main
()
{
double*
pvalue = NULL; // Pointer initialized with null
pvalue =
new double; // Request memory for the variable
*pvalue =
29494.99; // Store value at allocated address
cout
<< "Value of pvalue : " << *pvalue << endl;
delete pvalue; //
free up the memory.
return 0;
}
If we
compile and run above code, this would produce the following result:
Value of pvalue : 29495
Dynamic Memory Allocation for Arrays:
Consider
if we want to allocate memory for an array of characters, i.e., string of 20
characters. Using the same syntax what we have used above we can allocate
memory dynamically as shown below.
char* pvalue = NULL; //
Pointer initialized with null
pvalue = new char[20]; //
Request memory for the variable
To remove
the array that we have just created the statement would look like this:
delete [] pvalue; // Delete
array pointed to by pvalue
Following
the similar generic syntax of new operator, you can allocat for a
multi-dimensional array as follows:
double** pvalue = NULL; //
Pointer initialized with null
pvalue = new double [3][4]; //
Allocate memory for a 3x4 array
However,
the syntax to release the memory for multi-dimensional array will still remain
same as above:
delete [] pvalue; //
Delete array pointed to by pvalue
Dynamic Memory Allocation for Objects:
Objects
are no different from simple data types. For example, consider the following
code where we are going to use an array of objects to clarify the concept:
#include
<iostream.h> class Box
{
public: Box() {
cout
<< "Constructor called!" <<endl;
}
~Box() {
cout
<< "Destructor called!" <<endl;
}
};
int main(
)
{
Box*
myBoxArray = new Box[4];
delete []
myBoxArray; // Delete array
return 0;
}
If we
were to allocate an array of four Box objects, the Simple constructor would be
called four times and similarly while deleting these objects, destructor will
also be called same number of times.
If we
compile and run above code, this would produce the following result:
Constructor
called!
Constructor
called!
Constructor
called!
Constructor
called!
Destructor
called!
Destructor
called!
Destructor
called!
Destructor
called!
Related Topics
Privacy Policy, Terms and Conditions, DMCA Policy and Compliant
Copyright © 2018-2024 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.