L'assignació de memòria dinàmica en C/C++ es refereix a realitzar l'assignació de memòria manualment per part d'un programador. La memòria assignada dinàmicament s'assigna activada Munt, i les variables locals i no estàtiques s'assignen memòria Pila (Consulteu Programes C de disseny de memòria per als detalls).

Què són les aplicacions?

• Un ús de la memòria assignada dinàmicament és assignar memòria de mida variable, cosa que no és possible amb la memòria assignada del compilador excepte per matrius de longitud variable .
• L'ús més important és la flexibilitat que ofereix als programadors. Som lliures d'assignar i desassignar memòria sempre que la necessitem i quan ja no la necessitem. Hi ha molts casos en què aquesta flexibilitat ajuda. Exemples d'aquests casos són Arbre , etc.

En què es diferencia de la memòria assignada a variables normals?

Per a variables normals com int a, char str[10], etc., la memòria s'assigna i desassigna automàticament. Per a la memòria assignada dinàmicament com int *p = new int[10], és responsabilitat del programador desassignar la memòria quan ja no la necessiti. Si el programador no desassigna la memòria, provoca a pèrdua de memòria (la memòria no es desassigna fins que finalitzi el programa).

Com s'assigna/desassigna la memòria en C++?
C utilitza el malloc() i calloc() funció per assignar memòria dinàmicament en temps d'execució i utilitza una funció free() per alliberar memòria dinàmicament assignada. C++ admet aquestes funcions i també té dos operadors nou i suprimir, que realitzen la tasca d'assignar i alliberar la memòria d'una manera millor i més fàcil.

nou operador

El nou operador indica una sol·licitud d'assignació de memòria a la botiga gratuïta. Si hi ha prou memòria disponible, un nou operador inicialitza la memòria i retorna l'adreça de la memòria recentment assignada i inicialitzada a la variable punter.

Sintaxi per utilitzar l'operador nou

com llegir des d'un fitxer csv a java

pointer-variable =   new   data-type;>

Aquí, la variable punter és el punter del tipus tipus de dades. El tipus de dades podria ser qualsevol tipus de dades integrat, inclosa la matriu, o qualsevol tipus de dades definit per l'usuari, incloses l'estructura i la classe.
Exemple:

// Pointer initialized with NULL // Then request memory for the variable int *p = NULL;  p = new int;    OR  // Combine declaration of pointer  // and their assignment int *p = new int;>

// C++ program to demonstrate how to create dynamic variable // using new #include  #include  using namespace std; int main() {  // pointer to store the address returned by the new  int* ptr;  // allocating memory for integer  ptr = new int;  // assigning value using dereference operator  *ptr = 10;  // printing value and address  cout << 'Address: ' << ptr << endl;  cout << 'Value: ' << *ptr;  return 0; }>

Address: 0x162bc20 Value: 10>

Inicialitzar la memòria: També podem inicialitzar la memòria per als tipus de dades integrats mitjançant un operador nou. Per als tipus de dades personalitzats, cal un constructor (amb el tipus de dades com a entrada) per inicialitzar el valor. Aquí teniu un exemple de la inicialització dels dos tipus de dades:

pointer-variable =   new   data-type(value);>

Exemple:

// C++ program to illustrate how to initialize a dynamic // variable with allocation #include  #include  using namespace std; // Custom data type with constructor to take initial value struct cust {  int p;  cust(int q)  : p(q)  {  }  cust() = default; }; int main() {  // creating inbuit data types with initial value  int* p = new int(25);  float* q = new float(75.25);  // Works fine, doesn’t require constructor  cust* var1 = new cust;  // OR  // Works fine, doesn’t require constructor  var1 = new cust();  // Notice error if you comment this line  cust* var = new cust(25);  cout << *p << ' ' << *q << ' ' << var->p;  retorn 0; }>>>  
  Sortida  
25 75.25 25>
  
    Assigna un bloc de memòria:    també s'utilitza un nou operador per assignar un bloc (una matriu) de memòria de tipus    tipus de dades    .
 on size(una variable) especifica el nombre d'elements d'una matriu.
 
    Exemple:    
comanda zip a linux
 
int *p = new int[10]>
Assigna dinàmicament memòria per a 10 nombres enters contínuament de tipus int i retorna un punter al primer element de la seqüència, al qual se li assigna top (un punter). p[0] fa referència al primer element, p[1] fa referència al segon element, i així successivament.
 
 
 
 
 
    Declaració de matriu normal vs ús de nou       
Hi ha una diferència entre declarar una matriu normal i assignar un bloc de memòria amb new. La diferència més important és que les matrius normals són desassignades pel compilador (si la matriu és local, aleshores es desassigna quan la funció torna o es completa). Tanmateix, les matrius assignades dinàmicament romanen sempre allà fins que el programador les desassigna o el programa finalitza.
 
    Què passa si no hi ha prou memòria disponible durant el temps d'execució?       
Si no hi ha prou memòria disponible a la pila per assignar-la, la nova sol·licitud indica un error llançant una excepció del tipus std::bad_alloc, tret que no s'utilitzi nothrow amb l'operador nou, en aquest cas retorna un punter NULL (desplaceu-vos a la secció Excepció). maneig de nou operador a  això  article). Per tant, pot ser una bona idea comprovar la variable punter produïda pel nou abans d'utilitzar el seu programa.
 
int *p = new(nothrow) int; if (!p) {  cout << 'Memory allocation failed
'; }>
    suprimir l'operador    
Com que és responsabilitat del programador desassignar la memòria assignada dinàmicament, els programadors reben un operador de supressió en llenguatge C++.
 
    Sintaxi:     
 
// Release memory pointed by pointer-variable   delete   pointer-variable;>
Aquí, la variable punter és el punter que apunta a l'objecte de dades creat per      nou      .
 
    Exemples:    
introduint una cadena en java
 
delete p; delete q;>
Per alliberar la matriu assignada dinàmicament apuntada per la variable punter, utilitzeu la forma següent de    esborrar    :
 
  // Release block of memory     // pointed by pointer-variable  delete[] pointer-variable;     Example:    // It will free the entire array    // pointed by p.   delete[] p;>
CPP 
// C++ program to illustrate dynamic allocation // and deallocation of memory using new and delete #include  using namespace std; int main() {  // Pointer initialization to null  int* p = NULL;  // Request memory for the variable  // using new operator  p = new (nothrow) int;  if (!p)  cout << 'allocation of memory failed
';  else {  // Store value at allocated address  *p = 29;  cout << 'Value of p: ' << *p << endl;  }  // Request block of memory  // using new operator  float* r = new float(75.25);  cout << 'Value of r: ' << *r << endl;  // Request block of memory of size n  int n = 5;  int* q = new (nothrow) int[n];  if (!q)  cout << 'allocation of memory failed
';  else {  for (int i = 0; i < n; i++)  q[i] = i + 1;  cout << 'Value store in block of memory: ';  for (int i = 0; i < n; i++)  cout << q[i] << ' ';  }  // freed the allocated memory  delete p;  delete r;  // freed the block of allocated memory  delete[] q;  return 0; }>
   
  Sortida  
Value of p: 29 Value of r: 75.25 Value store in block of memory: 1 2 3 4 5>
 
    Complexitat temporal:    O(n), on n és la mida de memòria donada.
 
    Articles relacionats:    
 
 Test sobre nou i suprimir 
 eliminar vs gratis