Memory management with C ++

c++ memory management

Sometimes we don’t know how much space is required for a data. For example, we can’t know how many characters the name is to enter when we want the name from the user. To do this, we need to give an upper limit. What if the user enters more? Or we can’t know the size of a file when reading data from a file.

Memory management with C ++

The size of all variables we normally use is known at compile time and the program is written accordingly. We have to allocate space while the program is running for data that we do not know the size.

We do this with the new statement. Its use is as follows.

degiskenturu *degisken adi = new degiskenturu

We do Dynamic Data allocation with pointers.

int *ptr = new int; //Dinamik yer ayirma

then we can value it with the * operator.

*ptr = 10;

C++ management

When we dynamically allocate space from memory, we specify that we want to allocate space to the operating system. If you have ramde space, the operating system is returning us an address from ramden.

Give the first value to the dynamic allocated variable

In C++11, we can do this as follows.

int *x = new int(5);
int *y = new int{15};

When we are finished with the dynamically allocated location, we need to return the location we received to the operating system. If we don’t do this, ramde’s a trash hole. It’s called memory leak.

To do this, the DELETE statement is used.

delete x;

If the pointer is not used, you must synchronize the pointer to nullptr.

x = nullptr;

The undefined behavior is to dereference the deleted pointer. So the data may still be there, or the operating system may be hiding it for another program.

C++ Memory Details

It is a good idea to synchronize the pointers to nullptrye, which we will never use again.

Dynamic reserved arrays

New[] and delete[] are used for arrays.

#include <iostream>
int main()
{
std::cout << “Enter a positive integer: “;
int length;
std::cin >> length;
int *array = new int[length]; // lenth sabit olmak zorunda degildir.
std::cout << “I just allocated an array of integers of length ” << length << ‘n’;
array[0] = 5; // set element 0 to value 5
delete[] array; // use array delete to deallocate array
array = nullptr;
return 0;

}

the language is not a problem because it knows that we have reserved space for the series while writing new [].

Dynamically free memory for reserved arrays

We have to use delete[] when doing this. Normal delete causes undefined behavior.

If you want all elements of the dynamic array to be zero during the definition, you can type the following.

int *dizi = new int[10]();

You can define your arrays as follows thanks to a feature that comes with C++11.

int *dizi = new int[10] {1,2,3,4,5,6,7,8,9,10};

Resize sequences

C++ does not directly offer such a feature, but you can encode it yourself. Instead, you can use the std::vector as a standard library member.

 

Leave A Reply

Your email address will not be published.