Как да работя с динамично разпределение на паметта C ++?

Динамично разпределение на паметта В C ++ е много важна функция, която ви позволява да прецените вашите изисквания, за да се справите с необходимостта от ресурси в реално време. В тази статия ще проучваме Изследване в детайли. Следните указания ще бъдат разгледани в тази статия,

• Нуждаете се от динамично разпределение на паметта?
• Разпределение на паметта с помощта ново Ключова дума
• Предоставяне на памет с използване Изтрий Ключова дума
• Динамично разпределяне на масиви
• Динамично разпределение на паметта за обекти

Така че нека да започнем с тази статия за динамичното разпределение на паметта в C ++

Нуждаете се от динамично разпределение на паметта?

Да кажем, че искаме да въведем изречение като масив от символи, но не сме сигурни за точния брой символи, необходими в масива.

код на фибоначи c ++

Сега, докато декларираме масива от знаци, ако посочим неговия размер по-малък от размера на желания низ, тогава ще получим грешка, тъй като мястото в паметта, разпределено на масива, е по-малко в сравнение с размера на входния низ. Ако посочим неговия размер по-голям от размера на входния низ, тогава на масива ще бъде разпределено пространство в паметта, което е много по-голямо от размера на желания низ, като по този начин ненужно консумира повече памет, дори когато не се изисква.

В горния случай нямаме представа за точния размер на масива до времето за компилация (когато компютърът компилира кода и низът е въведен от потребителя). В такива случаи използваме ново оператор.

C ++ дефинира два унарни оператора ново и Изтрий които изпълняват задачата за разпределяне и освобождаване на памет по време на изпълнение. Тъй като тези оператори (нови и изтрити) работят върху свободната памет (Heap memory), те също се наричат ​​безплатни оператори. Указателите осигуряват необходимата поддръжка за системата за динамично разпределение на паметта в C ++.

С помощта на Dynamic Allocation една програма може да получи памет по време на изпълнение.

Глобалната и локалната променливи се разпределят в паметта по време на компилация. Не можем обаче да добавяме никакви глобални или локални променливи по време на изпълнение. Ако програмата трябва да използва променлив обем памет, ще трябва да разпределим памет по време на изпълнение, както и когато е необходимо. И разбира се, тук процедурите за динамично разпределение могат да служат на целта.

Разлики между разпределението на статичната памет и динамичното разпределение на паметта:

Това е основна архитектура на паметта, използвана за всяка програма на C ++:

Ще ни трябва подобно изображение

Стекът се използва за статично разпределение на паметта и Heap за динамично разпределение на паметта, като и двете се съхраняват в RAM паметта на компютъра.

Променливите, които се разпределят в стека, докато разпределението на статична памет се съхранява директно в паметта и достъпът до тази памет е много бърз, също така нейното разпределение се разглежда, когато програмата се компилира. Когато функция или метод извика друга функция, която от своя страна може да извика друга функция и т.н., изпълнението на всички тези функции остава спряно, докато последната функция не върне стойността си. Стекът винаги се съхранява в ред LIFO (последен при първото излизане), последният резервиран блок винаги е следващият освободен блок. Това помага да се следи стека, освобождаването на блок от стека не е нищо повече от настройка на един указател.

Разпределените в купчината променливи имат своята памет, разпределена по време на изпълнение, докато динамично разпределение на паметта. Достъпът до тази памет е малко по-бавен в сравнение със стека, но размерът на купчината е ограничен само от размера на виртуалната памет. Елементът на купчината няма взаимни зависимости и винаги може да бъде достъпен произволно по всяко време. Можем да разпределим блок по всяко време и да го освободим по всяко време. Това затруднява проследяването на това кои части от купчината са разпределени или освободени по всяко време.

Продължавайки с тази статия за динамичното разпределение на паметта в C ++

Разпределение на паметта с помощта ново Ключова дума

В C ++ ново оператор се използва за разпределяне на памет по време на изпълнение и паметта се разпределя в байтове. The ново операторът означава заявка за динамично разпределение на паметта в Heap. Ако има достатъчно памет, тогава ново операторът инициализира паметта и връща адреса на новоразпределената и инициализирана памет към променливата на указателя.

Синтаксис:

тип данни * име на указател = нов тип данни

Пример:

int * ptr = new int // Можем да декларираме променлива при динамично разпределение по следните два начина. int * ptr = new int (10) int * ptr = new int {15} // new operator също се използва за разпределяне на блок (масив) памет от тип data-type. int * ptr = new int [20] // Горният оператор разпределя динамично памет за 20 цели числа непрекъснато от тип int и връща указател към първия елемент от последователността към указателя ‘ptr’.

Забележка : Ако купчината няма достатъчно памет за разпределяне, новата заявка показва неуспех чрез хвърляне на изключение std :: bad_alloc, освен ако с новия оператор не се използва “nothrow”, в който случай връща NULL указател. Следователно е добра практика да проверите за променливата на указателя, създадена от new, преди да я използвате в програмата.

Продължавайки с тази статия за динамичното разпределение на паметта в C ++

Предоставяне на памет с използване Изтрий Ключова дума:

След като паметта на купчината се разпределя към променлива или обект на клас с помощта на ново ключова дума, можем да освободим това пространство в паметта с помощта на Изтрий ключова дума.

Синтаксис:

delete pointer_variable // Тук pointer_variable е указателят, който сочи към обекта на данни, създаден от new. delete [] pointer_variable // За да освободим динамично разпределената памет на масива, посочена от pointer-променлива, използваме следната форма на изтриване:

Пример:

delete ptr delete [] ptr

Забележка : Обхватът на обекта или животът на обекта е времето, през което обектът остава в паметта по време на изпълнението на програмата. Разпределението на купчина памет е по-бавно от стека, тъй като в купчината няма определен ред, по който можете да разпределите памет, докато в стека той следва LIFO.

Продължавайки с тази статия за динамичното разпределение на паметта в C ++

Динамично разпределяне на масиви

Основното използване на концепцията за динамично разпределение на паметта е за разпределяне на паметта в масив, когато трябва да я декларираме, като посочим нейния размер, но не сме сигурни за това.

Да видим, пример за разбиране на използването му.

#include използвайки пространство от имена std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>len int * marks = new int [len] // Динамично разпределение на паметта cout<< 'Enter the marks of each student' << endl for( int i = 0 i>* (марки + i)} за (int i = 0 i
 Обяснение:  
В този пример първо питаме потребителя за броя на учениците в клас и съхраняваме стойността му в променливата len. След това декларираме масив от цяло число и му разпределяме пространство в паметта динамично равно на стойността, съхранена в променливата len, като използваме този израз int * marks = new int [length], като по този начин му се отрежда пространство, равно на 'length * (размер на 1 цяло число) '. Останалата част от кода е обяснима сама по себе си.
Продължавайки с тази статия за динамичното разпределение на паметта в C ++
 Динамично разпределение на паметта за обекти 
Можем също така динамично да разпределяме обекти.
Както знаем, че Constructor е специална функция за член на клас, използвана за инициализиране на обект, а Destructor също е функция за член на класа, която се извиква винаги, когато обектът излезе извън обхвата.
Destructor е може да се използва за освобождаване на паметта, присвоена на обекта. Извиква се при следните условия.
Когато локален обект излезе извън обхвата
За глобален обект, когато оператор е приложен към указател към обекта на класа
Можем отново да използваме указатели, докато динамично разпределяме паметта към обектите.
Нека да видим пример за масив от обекти.
#include използвайки пространство за имена std клас Random {public: Random () {cout<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } 
 Изход: 
как да се предотврати блокиране в java -
 Обяснение: 
Конструкторът ще бъде извикан три пъти, тъй като разпределяме паметта за три обекта от класа Random. Деструкторът също ще бъде извикан три пъти по време на всеки от тези обекти. ‘Random * a = new Random [3]’ това изявление отговаря за динамичното разпределение на паметта на нашия обект.
Така стигнахме до края на тази статия за „Динамично разпределение на паметта C ++“. Ако искате да научите повече, разгледайте   от Edureka, доверена компания за онлайн обучение. Курсът за обучение и сертифициране на Java J2EE и SOA на Edureka е предназначен да ви обучи както за основни, така и за разширени Java концепции, заедно с различни Java рамки като Hibernate & Spring.
 Имате въпрос към нас? Моля, споменете го в раздела за коментари на този блог и ние ще се свържем с вас възможно най-скоро.