Докато при динамичното разпределение на паметта паметта се разпределя, докато изпълнението е започнало. Тази памет се разпределя ръчно от програмиста по време на изпълнение, известно също като разпределение на памет по време на изпълнение в C++. Размерът на динамичната памет може да бъде променен на всяка позиция в програмата, тъй като по време на декларирането не споменаваме размер, който може да бъде фиксиран. Предоставяме само стойността директно на променливата.
Разлика в разпределението на паметта спрямо нормалните променливи
При нормалните променливи паметта, която е разпределена от компилатор, се разпределя и освобождава автоматично. Когато паметта се разпределя динамично от програмиста, той трябва да премахне или освободи паметта, когато тя е безполезна при по-нататъшното изпълнение на изходния код. Тази ситуация причинява „изтичане на памет“, когато програмата бъде прекратена, докато паметта не е освободена.
Оператори за динамично разпределение
В C++ два оператора помагат при разпределянето и освобождаването на паметта: „нов“ и „изтриване“, които се използват за разпределяне и освобождаване на паметта по по-добър начин.
Нов оператор
Това означава изискването за разпределение на паметта. Операторът new инициализира паметта и връща адреса на тази разпределена памет към променливата на указателя, ако има достатъчно налична памет.
Обект показалец = нов данни - Тип ;
Оператор за изтриване
Точно като новия оператор, операторът за изтриване се използва за премахване на разпределената памет. В C++ програмистът може да използва този оператор за освобождаване.
# Изтриване на pointer_variable;
Пример 1
В този пример ще въведем два указателя: единият е целочислен тип указател, а другият е плаващ указател. Указателите се инициализират чрез използване на знак звездичка с тях.
# Int * pointInt;# Float *pointfloat;
Използвайки тези два принтера, ние динамично ще разпределим паметта.
Роля на указателите в динамичното разпределение:
Паметта на пространството за съхранение е разработена под формата на блокове. Всеки път, когато изпълняваме програма или извършваме някаква операция, паметта се разпределя за тази конкретна цел. Тази памет има специален адрес, който е свързан с програмата, която идентифицира кой процес или програма е разрешен за тази памет. Всеки слот за памет се осъществява чрез адреса, към който принадлежи. Така че този адрес се съхранява чрез указателите. Накратко, имаме нужда от указатели за достъп до паметта и по същия начин за разпределяне на определена част от паметта за всяка задача. Указателите са необходими за съхраняване на адреси.
Тъй като ключовата дума „new“ се използва за динамично разпределение на памет при ръчно разпределение, паметта се разпределя от компилатора. Не е необходимо да разпределяме памет по време на изпълнение. Но тъй като динамичното разпределение е произволно, трябва да идентифицираме указателите и за процеса на свързване се използва този нов оператор.
# Pointint = ново int;По същия начин, плаващият указател е обвързан по същия начин. След процеса на обвързване ще присвоим произволна стойност на паметта, която искаме да резервираме за всяка операция. Като декларираме указателя, ние присвояваме специфична стойност на паметта.
# *pointInt = 50;Декларира се и стойност с плаваща стойност за плаващите точки. Показване на стойностите след присвояване.
Както обсъдихме, операторът „нов“ се използва за разпределяне, докато „изтриване“ се използва за освобождаване на памет. Така че след като завършите задачата или операцията в кода, ние ще премахнем паметта, която сме заделили за задачата.
По-добре е да освободите тази част от паметта, така че всеки друг процес да може да се възползва от това. Ще приложим това разпределение към двата указателя.
Изтриване на точка плавам ; 
След като запишете кода в текстовия редактор, терминалът на Ubuntu ви позволява да изпълните изходния код във файла чрез g++ компилатор.
$ g++ -o mem mem.c$ ./мем
При изпълнение ще видите стойностите, присвоени на паметта.
Пример 2
Този пример включва взаимодействие с потребителя. Ще вземем числова променлива, която ще съдържа стойност от потребителя. Тази програма ще съхранява резултата в GPA на учениците. Всички резултати ще бъдат запазени по време на изпълнение.
Когато потребителят въведе броя на учениците, паметта се разпределя за всеки номер. Тук се инициализира указател тип float, който ще се използва при разпределението на паметта на резултатите.
Взимаме указателя в float, тъй като GPA е в десетична система. Взимаме масив от тип указател за GPA, тъй като може да доведе до определен брой студенти.
Този масив от указатели с ключовата дума „new“ ще обвърже изпълнението с паметта. Среден успех ще бъде въведен за всеки ученик. Тъй като не сме запознати с броя на учениците, които потребителят иска да добави, използвахме for цикъл, за да въведем GPA до въведеното число. При всяко повторение на цикъла потребителят се подканва да въведе резултата, идентифициращ ученика. След като резултатът бъде запазен, ние отново ще използваме цикъл, за да покажем всички GPA на учениците. В крайна сметка масивът от указателни типове се изтрива, тъй като целта на динамичното съхранение е постигната.
Изтрий [ ] ptr ;Сега ще изпълним гореспоменатия код. Потребителят първо ще бъде помолен да въведе броя на учениците. След това ще бъде въведен среден успех за всеки ученик.
Пример 3
Този пример използва операторите new и delete за обекта на класа. Този клас съдържа частна променлива от целочислен тип, която съхранява възрастта. В публичната част на класа се създава конструктор, който ще инициализира възрастта на числото „10“. Тук се използва друга функция, която ще покаже възрастта, която е инициализирана в конструктора.
Сега ще преминем към основната програма за динамично разпределение. Обектът на класа се създава динамично.
Студент * ptr = нов студент ( ) ; 
Когато обектът се формира, конструкторът ще бъде внедрен автоматично. Ще бъде направено извикване на функция, за да се получи възрастта. Това ще стане чрез ptr.
Ptr - > getAge ( ) ;И накрая паметта ще бъде освободена.
Заключение
Динамичното разпределение на паметта се разпределя по време на изпълнение от програмиста вместо фиксирано съхранение, идентифицирано от компилатора. Това разпределение е на случаен принцип и може да бъде елиминирано, след като бъде използвано. Докато в повечето случаи, преди премахването, процесът на изпълнение спира и това динамично разпределение след това причинява изтичане на памет. Ние внедрихме този феномен в различни подходи в системата Ubuntu Linux, използвайки език за програмиране C++.