Computer Code C

Static & Dynamic memory allocation

MEMORY LEAK

2020-07-15T22:38:00.006+05:30

What actually happens when we delete a pointer ?

A pointer is like any other variable when it comes to taking space in the memory. But instead of storing any values, it stores the memory address of the block it is pointing to. We know that by using delete we can free the dynamically allocated memory. But the point to keep in mind is that the pointer itself is not dynamically created. It just holds the address of a dynamically created memory block. This means that the pointer cannot be deleted using delete keyword, but the memory it’s pointing to can be deleted.

Look at the following code and then see the explanations :

#include<iostream>

using namespace std;

int main()

{

int * iptr; // statement 1

iptr = new int(25); // statement 2

delete iptr; // statement 3

iptr = new int(12); // statement 4

return 0;

}

Statement 1 creates an integer pointer iptr. This means the compiler provides a space of 8 bytes to iptr somewhere in the memory. As it is not initialized, iptr, at present, doesn’t hold any address.

Statement 2 is the dynamic allocation statement (allocation using new). It creates a 4 bytes space in memory somewhere, stores the value 25 in it and then returns its address to iptr.

Statement 3 uses the deallocation operator delete. This does not delete the pointer iptr, as it may seem from the code. The deleteoperator can only deallocate the memory created through new. By using the pointer, we simply specify the address to be deleted. So, after delete, iptris still present in the memory till its scope is over. This is shown in statement 4 where we use the pointer again to create another memory block using new.

Also, when we delete a memory block, we are not talking of actually deleting the value stored in that block. The block is passed back to operating system for reuse, may be with the value still stored in it as a garbage value or clearing it. C++ does not make any guarantees about what will happen to the contents of deallocated memory. All we know is further dynamic creations of memory using new can utilize the deleted memory.

Dangling Pointers

C++ gives no clue as to what value is stored in the pointer after a delete statement. In most cases, the memory returned to the operating system will contain the same values it had before it was returned, and the pointer will be left pointing to the now deallocated memory.

A pointer that is pointing to a deallocated memory is called dangling pointer. Dereferencing or deleting a dangling pointer will lead to undefined behaviour.

Consider the following program :

In the above program, the value of 7 that was previously assigned to the allocated memory will probably still be there, but it’s possible that value at that memory address could have changed. It’s also possible the memory could be allocated to another application (or for the operating system’s own usage), and trying to access that memory will cause the operating system to shut the program down.

Few precautions that will avoid dangling pointer errors

First, try to avoid having multiple pointers point to the same memory location. If this is not possible, always be clear about all the pointers accessing the same memory address.

Second, when you delete a pointer, if that pointer is not going out of its scope immediately afterward, set its value as NULL or nullptr.

Memory Leaks

There is no doubt about the fact that new and deleteare very useful. But they have an associated problem that it is easy to forget to delete something that was previously allocated with new, leaving an orphaned memory block – a block that is still allocated but which has nothing referencing it. This means that a memory block which was created is still in use but there’s no way to access it.

Here are the many reasons that might lead to memory leak :

Forgetting to delete something that has been dynamically allocated (using new).

There can be a number of instances where you might forget to delete a memory allocated through new. One such very common example is not deleting a dynamic memory created within a function. Look at the following code :

void fun ()

{

int * iptr = new int;

/* full function body */

}

In the above function, the memory allocated through new is never freed. Every time this function is called, a new memory is created which is later not deleted. These dynamically allocated memories have a dynamic scope and remain in memory for the entire program run. As a result, there is a continuous memory leak each time the function is called.

Failing to notice that code may bypass a delete statement under certain circumstances :

Consider the code below :

void fun()

{

int n; cin>>n;

int * iptr = new int;

* iptr = n;

if (* iptr < 6)

cout << “Less than 6” ;

else

delete iptr;

}

The above code is absolutely fine when it comes to syntax. Thus, the compiler shows no error. But if the user inputs a number less than 6, the control never actually passes to the deletestatement. So, every time the function is called and the user inputs a number less than 6, memory is lost.

Assigning a new address to a pointer which was already pointing to an allocated object.

See the code below :

int main()

{

int a = 5;

int * iptr = new int;

iptr = &a;

return 0;

}

Here, a is a static variable which has a certain address. A new memory is dynamically allocated which is being pointed to by the pointer iptr. Now when the address of a is assigned to iptr, the address of the dynamically allocated memory is lost. There is no way to access that memory block. Thus, it results in a memory leak.

What is the actual meaning of memory leak ?

Every program at the time of compilation is sent to the compiler. The compiler reads the program and if it finds no errors it feeds the program to the main memory. Every program is given a certain amount of memory. This is the memory a program can use in its entire run. This memory includes spaces for global variables, local variables and functions; as well as the heap memory for dynamic allocations.

Whenever a new memory block is created using new, a part of this heap is used. As heap is not infinite, it may happen that all the heap is used up and there is no space left for creation of a new memory block. To reduce this risk, it is important to avoid memory leaks. It is very important to free the memory that is no longer needed so that it may be used again by the program.

Whenever a memory address is leaked, the operating system still considers that memory block to be useful to the program. But once the memory is leaked, we have no way to get back its address in order to modify or delete it. So, that particular memory block becomes completely useless for rest of the program. This memory block remains in the memory until the program completely terminates.

Which topics you want an article on? Comment down on this post.

Do not stop here. Read all articles related to C++ here.

If you want to contribute any article for the website, feel free to share it on coding.nkcoder@gmail.com. We will publish it on the website with your name.

Download the pdf form of this article here.

Related Topics :

Introduction to pointers

Declaration and Initialization of pointers

Static & Dynamic Memory Allocations

DYNAMIC ALLOCATION OPERATORS

2020-07-14T19:03:00.007+05:30

Computer's memory is an interesting thing. The way it works is so complex yet highly interesting.

Pointers provide necessary support for C++’s powerful dynamic memory allocation system. As you know, dynamic allocation is the means by which a program can obtain memory during runtime. The global and the local variables are allocated memory during compile-time. However, you cannot add any global or local variables during runtime.

What if, your program needs to use variable amount of memory space? In such case, you would need to allocate memory during runtime, as and when required. This can be done using the dynamic allocation operators.

DYNAMIC ALLOCATION OPERATORS IN C++

C++ dynamic allocation routines obtain memory for allocation from the free store (the pool of unallocated heap memory provided to the program). C++ defines two unary operators new and delete that perform the task of allocating and freeing (deallocating) memory during runtime. In addition to these two operators, the C language functions malloc()and calloc() are also defined in C++. Since all these operate on the free memory, they are collectively called free store operators & functions. We will focus on new and delete. However, here’s a brief about malloc()and calloc() :

malloc()

It is a C based dynamic memory allocator used to allocate memory from heap region during runtime. It is included in the header cstdlib.

The general syntax for malloc() is :

pointer_name = (* data_type) malloc (size) ;

pointer_name is a pointer to type data_type.

data_type is the type of values you want to store in the memory.

size is the total number of memory blocks of type data_type you want.

malloc() is generally used to create dynamic arrays. It searches the memory for a suitable address where the array of proper size can be created and returns the base address of the first memory block. If it fails to allocate memory, it returns NULL. It is important to note that malloc() only allocates memory but does not initialize it. Therefore, all the allocated memory contains garbage value.

calloc()

It is also an inbuilt function included in the header file cstdlib. It is used to allocate memory from heap region during runtime.

The general syntax is :

pointer_name = (*data_type) calloc (no_of_blocks , size_of_each_block) ;

pointer_name is a pointer of type data_type

data_type is the type of values to be stored in the memory

no_of_blocks is an integer denoting the number of continuous memory blocks required

size_of_each_block denotes size of each memory block in bytes.

If calloc() fails to allocate memory, it returns a NULL. Also, unlike malloc(), it allocates and also initializes the memory blocks with legal default value depending on the data_type.

Learn all about malloc() and calloc() here. (link will be ready shortly.)

The ‘new’ operator

The operator new can be used to create objects of all kinds, including user defined data types such as class or structures.

The general syntax for object creation using new :

pointer_name = new data_type ;

where data_type is any valid C++ data type and the pointer_name is a pointer variable of type data_type.

The operator new will allocate memory of size equal to the size of given data_type and return a pointer (of that specified data_type) pointing to the base address of the newly allocated area.

For instance, the following code snippet

iptr = new int ;

This will allocate sufficient amount of memory from free storage to hold a value of specified data_type and store the starting address of the newly allocated memory in iptr. Since new is allocating the memory for int type, the receiving pointer must be of int type i.e. iptr must be an intpointer.

Declaration and allocation can be combined in one statement as :

int * iptr = new int ;

Once a pointer points to a legal memory, we can access that memory using the “value at” operator * of pointers as shown below :

*iptr = 12 ;

The above assignment will assign the integer value 12 into the newly allocated memory block.

This assignment can also be done at the time of allocation as :

pointer_name = new data_type (value);

where value is the initial value to be stored in the newly allocated memory. The value must also be of the specified data_type type .

Consider the following statements

char *cptr = new char (‘a’); // statement 1

float *fptr = new float (17.33); // statement 2

The above given statement 1 will allocate sufficient memory from free pool to hold a character, then store ‘a’ inside this newly allocated memory, and make character pointer cptr point to this memory address.

Similarly, the statement 2 will allocate sufficient memory from free pool to hold a floating point value, then store 17.33 inside that newly allocated memory, and make float pointer fptr point to that memory address.

Creating Dynamic Array

The operator new can also allocate memory for user defined types like structures and classes as well as for derived data types like arrays. To allocate memory for a one-dimensional array, new may be used in the following form :

pointer_name = new data_type [size] ;

where size is an integer representing the number of elements in the array.

For instance, to allocate memory for an array having 10 integer elements we need to use new as :

int * a = new int [10] ;

This will create an array of size 10 with a pointing to the base address of the first element. Now all these array elements can be accessed as

a[0] for the first element

a[1] for the second element

a[2] for the third element….and so on.

Before C++11 standards, no initializations were possible at the time of creation of array but now we can also initialize the array with some initial values as

int * a = new int [5] {2, 5, 3, 8, 10} ;

This creates an array a with a[0] = 2, a[1] = 5 and so on.

The new operator does not initialize the newly created memory unless explicitly forced by the programmer.

See the following code and its output :

#include<iostream>

using namespace std;

int main()

{

int * a= new int;

cout<< *a;

return 0;

}

Output :

1448160

The output is certainly a garbage value which is at present stored in the newly created memory.

Now see this code :

#include<iostream>

using namespace std;

int main()

{

int * a= new int (); // explicitly forcing initialization

cout<< *a;

return 0;

}

Output :

As evident from above examples, to initialize memory allocated through new, the program needs to force this initialization explicitly. Also, arrays can be initialized with legal default values in the same way.

int * a= new int [5]();

This code creates an array of 5 elements and initializes the elements with the default value of int type, i.e. 0.

In older versions of C++, it was not possible to create a static array of variable size. For example,

int n;

cin>>n;

int a[n];

The above code would generate error as a variable has been passed as the size of array. But the new standards allow such creations and so the use of dynamic creation of arrays has now reduced.

An important note :

Since the program’s free store (heap) is not infinite, during the course of program execution, it may become exhausted i.e. the program may run out of heap memory and more memory may not be allocated further. To be on the safer side in such a situation, whenever you allocate memory, you must check the value returned by new operator to make sure it is not NULL or zero before using the pointer. Using a NULL pointer will almost certainly crash the system.

int *val = new int;

if(val)

*val=7;

else

cout<<”Out of memory !!” ;

Even if, the initial value is given in the expression, initialization is done only if the value returned by operator new is nonzero (or non-NULL). If the value returned by new is 0 (NULL), the value of entire expression becomes 0 (i.e. false).

The ‘delete’ operator

When an object, created through new, is no longer needed, it must be destroyed so that the memory space occupied by it may be released for reuse. This can be done with the help of delete operator, the memory deallocation operator of C++.

The general form of delete is as shown below :

delete pointer_name ;

where pointer_name is the pointer that points to a data object created through new.

For deleting dynamic arrays created by new, we use the following syntax :

delete [] pointer_name ;

Note : When we apply delete to a pointer, it essentially deletes that memory which the pointer is pointing to. It does not mean that the pointer itself is deleted. Any pointer is first a static variable itself and it remains in memory for its entire scope.

If you like this article share with your friends.

Do not stop here. Read all articles related to C++ here.

If you have any doubts, queries or suggestions for the website, please comment on this post.

If you want to contribute any article for the website, feel free to share it on coding.nkcoder@gmail.com. We will publish it on the website with your name.

Download the pdf form of this article here.

Related Topics :

Introduction to Pointers

Declaration and Initialization of pointers

Static and Dynamic Allocation of memory

POINTER ARITHMETIC

2020-07-13T23:54:00.005+05:30

In this article we will see which operators work with pointers and how they operate on them. The study of this topic is termed as Pointer Arithmetic.

POINTER ARITHMETIC

Before we start discussing about the arithmetic of operators, it is important that we understand how pointers store memory address. As we know, pointers are variables that hold memory address of other variables, any modification in the value of a pointer means changing the memory address to which it is pointing.

How does Computer Memory look like?

Visualize the computer memory as a table consisting of number of rows & columns depending on the memory capacities of the computer. Each of the boxes formed by the intersection of rows and columns has a size of 1 byte. Now each of these boxes have a memory address which are sequential (say 1,2,3, ……. and so on).

A general representation of computer memory

Now, when a variable is created, a number of these sequential memory boxes merge to give rise to a new box of required size. For instance,

Suppose we create an integer variable.

int a;

As soon as the compiler reads this variable, it merges 4 sequential memory boxes to give rise to a new memory box of size 4 bytes (i.e. size of int variable). This new memory box is given the same address as its first constituting box. Suppose a is at address 117.

See the figure below to understand how the memory looks now :

Variable created at Base address 117

Note that the address of variable is saved as 117 (i.e. the starting position box). The location of first box is termed as Base Address for that variable.

Similarly, a char variable takes just 1 box(1 byte), a float variable takes 4 boxes, a double variable takes 8 boxes and so on!

Operators working on pointers

Only two arithmetic operations, addition and subtraction, may be performed on a pointer. When you add 1 to a pointer, you are actually adding the size of whatever the pointer is pointing at. That is, each time a pointer is incremented by 1, it points to the memory location of the next element of its base type. To understand it more clearly, let us take the previous figure.

Now consider the following code :

int * iptr; // create an int pointer

iptr = & a; // make iptr point to a

iptr++; // increment iptr

Let’s visualize and discuss every step:

Statement 1 : It creates an integer pointer (i.e. a pointer pointing to an integer). As its not initialized, at present it is not pointing at anything. But being a variable, it does take space in the memory (8 bytes). Say it’s address is 100.

Look at the memory now.

Pointer variable created at Base Address 100

Statement 2 : It stores the address of variable ‘a’ in the pointer iptr.

Base address of variable stored in pointer

Statement 3 : Now this is the important step. What happens when the pointer value is incremented? As one might think, the value stored in iptr is increased by one. So, it should point to the next memory block. But, after 117 the next three addresses (viz. 118, 119 & 120) are not free. They are integrated together to form the variable a. So, the pointer sees 121 as the next memory block. Being an int type pointer, iptr readily converts the box at 121 into an integer by including the next 3 boxes.

So, the value stored in iptr is 121 and the memory looks like the figure below:

Memory after incrementation

I hope the concepts are clear now. Also decrement operator works the similar way. Suppose an int pointer holds the address 100 then after decrementing once, it will point at 96 and not 99.

When a character pointer is incremented, its value increase by one or whatever the size of character on your machine; an integer pointer when incremented, its value increases by four (or whatever the size of integer on your machine); a float pointer when incremented, its value increases by four; and so on.

In pointer arithmetic, all pointers increase and decrease by the length of the data type they point to.

Not just 1 but other integers may also be added to or subtracted from pointers. When you give the following expression:

iptr += 2;

it will make iptr point to the 2^nd element of iptr’s type (int here) beyond the one it is currently pointing to. That is, if iptr is currently pointing to memory location 1001, then iptr +2 will make it point to address 1009, which is the result of 1001 + size of (2 integers)=1001 + 8 = 1009.

Other arithmetic operations like multiplication and division are not permitted on pointers. Also, you may not add two pointers and only integers can be added or subtracted from pointers.

When we say that it is a char pointer or int pointer or float pointer, we mean to say that this pointer is holding address of a memory location that can hold char, or int or float value respectively. However, for char value, the memory location is 1 byte wide; for int it is 4 bytes; and 4 bytes for float. Whatever may be the pointer type, the pointer holds the address of the very first byte (known as the Base Address) of the memory location it points to.

Do relational operators act on pointers?

Yes, the relational operators == and != act on pointers. These operators can be used to check the pointer value against some other values, like checking if the pointer points to NULL or not.

See the following code for example :

#include<iostream>

using namespace std;

int main()

{

int * iptr = NULL; // initializing iptr with NULL

if(iptr == NULL) // Using relational operator

cout << “It is NULL ”; // Output statement

return 0;

}

Output:

It is NULL

Here another thing can be understood that dereferencing a NULL pointer causes error. This is due to the fact that a NULL pointer is not pointing at any valid memory address. So, dereferencing it doesn’t mean anything logical.

Do not stop here. Read all articles related to C++ here.

If you have any doubts, queries or suggestions for the website, please comment on this post.

If you want to contribute any article for the website, feel free to share it on coding.nkcoder@gmail.com. We will publish it on the website with your name.

Download the pdf form of this article here.

Related Topics :

Introduction to pointers

Declaration and Initialization of pointers

Static and Dynamic Allocation of Memory

DECLARATION AND INITIALIZATION OF POINTERS

2020-07-12T23:18:00.027+05:30

In this article we will look in details of declaration and initialization of a pointer variable. As we know, pointers are one of the most important and strongest features of C++, it becomes necessary to know about them in details.

DECLARATION AND INITIALIZATION OF POINTERS

Pointer variables are declared like normal variables except for the addition of the unary * character. The general form of a pointer declaration is as follows :

data_type *var_name;

Here data_type is any valid C++ data type and var_name is the name of the pointer variable.

See some examples of declarations :

int * iptr; // creates an integer pointer iptr

char * cptr; // creates a character pointer cptr

float * fptr; // creates a float pointer fptr

When we say that iptr is an integer pointer, it means that the memory location being pointed to by the pointer can hold only integers values. In other words, it can be stated that iptr is a pointer to integer. Similarly, in the above given declarations, cptr is a pointer to a character and fptr is a pointer to floating point value.

Thus, the base type of the pointer defines what type of variables the pointer can point to.

Note: Technically, any kind of pointer can point anywhere in the memory. However, all pointer arithmetic is done relative to its base type, so it is important to declare the pointers correctly. This is the reason why compiler shows error when we try to assign variable of a different data type to a pointer of different base type.

How much space does a pointer take?

As a pointer is also a proper data type (derived), it takes space in the memory just like any primitive data type. But the size of a pointer variable is not dependent on its base type. Every pointer, irrespective of its base type, takes 8 bytes of space in memory(64 bit system).

Does an empty pointer take space?

Well, yes. As soon as a pointer is created, it is given an 8 bytes space in the memory. When we assign the address of another variable to it, it simply stores the address value. It is similar to creating, say an int variable and then storing a value to it. Even if no value was assigned to that intvariable, it would still take up the space. The memory allocating statement is the declaration and not initialization.

Special Operators for Pointer handling

Two special operators * and & are used with pointers.

The & is a unary operator that returns the memory address of its operand.

For example,

int i = 25; // declares an int variable i

int * iptr; // declares an int pointer iptr

iptr = &i; // stores the memory address of i into iptr

The above given assignment statement stores the memory address if i (& returns address of its operand) into iptr so that iptr is now pointing to the memory location of i. The expression &i will return an int pointer value because i is integer type. Similarly, if ch is a character type variable, &chwill return a character pointer.

To understand the above assignment better, assume that variable i uses memory location 1000 to store its value. And the value stored in i is 25, then after the statement iptr = &i, iptrwill have the value 1000.

Following figure illustrates this concept.

The second pointer operator, *, does the reverse of &. The unary operator * returns the value of the variable located at the address following it.

For example, if iptr contains the memory address 1000, then * iptr will return the value stored at location 1000.

Following figure illustrates this concept.

Using ‘*’ operator to change or access the value being pointed to by pointer is called Dereferencing.

Notes:

The pointer operator * (called “value at” sign) is the same symbol as multiply operator * and the pointer operator & (called “address of” sign) is same as bitwise ANDoperator &. But these operators have no relationship to each other. Both pointer operators * and & have a higher precedence than all other arithmetic operators except unary minus, with which they have equal precedence.

The operand of & operator can be any variable or object whose address we need, but the operand of *operator can only be a pointer variable.

Pointers pointing to incorrect data types

The pointer variables must always point to the correct type of data. For instance, when a pointer is declared to be of type int, the compiler assumes that the address being pointed to by this pointer, will hold integer values.

Consider the following code fragment :

double a,b ;

int * iptr;

cin>>a; // read float value for a

iptr = & a; // store the address of a into iptr

b = *iptr; // store the value being pointed to by iptr into b

The above code is intended to assign the value of a to bthrough the use of pointers, but it will not produce the desired result. Because iptr is an integer pointer, only 4 bytes (int size is generally 4 bytes) of information will be transferred to b, not the 8 bytes that normally make up a double type value. Thus, making a pointer point to incorrect type of data may lead to loss of information.

The “NULL” Pointer Value

A pointer variable must not remain uninitialized since dereferencing uninitialized pointers cause the system crashing. Even if you do not have any legal pointer value to initialize a pointer, you can initialize it with NULLpointer value. Assigning NULL to a pointer initializes it to a value which is not a legal pointer but it saves you from the ‘Big’ problem of uninitialized pointers. A program can later test a pointer against NULL(the zero pointer) to see whether it contains a legal pointer or not.

For example, consider the following code snippet :

int * iptr = NULL; // iptrgets initialized with NULL

…………………. ;

if(iptr != NULL)

{…. // use the pointer if it points to some legal address

}

Important :

The expression (iptr != NULL) is equivalent to expression (iptr). The zero pointer NULL is defined in the standard header file stddef.h. NULL is internally mapped as int 0 (zero).

nullptr – New addition in C++11 standard

Before the release of C++11 standard, defined as NULLfilled the role of null pointer. But in C++11, a new keyword namely nullptrhas been introduced, which is a distinguished null-point constant. So, now on (provided you are using C++11 standard compilers), you can initialize your pointers with nullptr.

For example,

char * cptr = nullptr;

int * iptr = nullptr;

Difference between NULL and nullptr is that –

NULL is not defined by C++, it is programmer or compiler defined whereas nullptr has been defined by C++ as a legal null pointer.

NULL is internally mapped as int 0 (zero) whereas nullptr is a legal empty pointer which is implicitly convertible and comparable to any pointer-type.

The inclusion of nullptr also removes a major problem.

Suppose you have two overloaded functions

int f1 (char *) ;

int f1 (int) ;

And we have two pointers as

char * cptr1 = NULL ;

char * cptr2 = nullptr ;

Now the function call f1(cptr1) would always map to f1(int) and not f1(char *) as NULL is internally mapped as an int.

But f1(cptr2) will always map to the function f1(char *).

Do not stop here. Read all articles related to C++ here.

If you have any doubts, queries or suggestions for the website, please comment on this post.

If you want to contribute any article for the website, feel free to share it on coding.nkcoder@gmail.com. We will publish it on the website with your name.

Download the pdf form of this article here.

Related Topics :

Introduction to Pointers