Dynamisk minnesallokering i C/C++ avser att utföra minnesallokering manuellt av en programmerare. Dynamiskt allokerat minne tilldelas Högen, och icke-statiska och lokala variabler får minne allokerat på Stack (Hänvisa till Minneslayout C-program för detaljer).

Vad är applikationer?

• En användning av dynamiskt allokerat minne är att allokera minne av variabel storlek, vilket inte är möjligt med kompilatorallokerat minne förutom för arrayer med variabel längd .
• Den viktigaste användningen är flexibiliteten för programmerare. Vi är fria att allokera och deallokera minne närhelst vi behöver det och när vi inte behöver det längre. Det finns många fall där denna flexibilitet hjälper. Exempel på sådana fall är Träd , etc.

Hur skiljer det sig från minne som är allokerat till normala variabler?

För normala variabler som int a, char str[10], etc, tilldelas och avallokeras minne automatiskt. För dynamiskt allokerat minne som int *p = new int[10] är det programmerarens ansvar att deallokera minne när det inte längre behövs. Om programmeraren inte avallokerar minne orsakar det en minnesförlust (minnet avallokeras inte förrän programmet avslutas).

Hur tilldelas/deallokeras minne i C++?
C använder malloc() och calloc() funktion för att tilldela minne dynamiskt vid körning och använder en free() funktion för att frigöra dynamiskt allokerat minne. C++ stöder dessa funktioner och har även två operatörer ny och radera, som utför uppgiften att fördela och frigöra minnet på ett bättre och enklare sätt.

ny operatör

Den nya operatören anger en begäran om minnesallokering på Free Store. Om tillräckligt med minne finns tillgängligt, initierar en ny operatör minnet och returnerar adressen för det nyligen allokerade och initierade minnet till pekarvariabeln.

Syntax för att använda ny operator

df loc

pointer-variable =   new   data-type;>

Här är pekarvariabeln pekaren av typen datatyp. Datatyp kan vara vilken inbyggd datatyp som helst inklusive array eller vilken användardefinierad datatyp som helst inklusive struktur och klass.
Exempel:

// 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>

Initiera minne: Vi kan också initiera minnet för inbyggda datatyper med en ny operatör. För anpassade datatyper krävs en konstruktor (med datatypen som indata) för att initiera värdet. Här är ett exempel på initiering av båda datatyperna:

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

Exempel:

// 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;  returnera 0; }>

25 75.25 25>

Tilldela ett minnesblock: en ny operatör används också för att allokera ett block (en array) av minne av typen data typ .

pointer-variable =   new   data-type[size];>

där storlek (en variabel) anger antalet element i en array.

Exempel:

romerska siffror diagram 1 100

int *p = new int[10]>

Tilldelar dynamiskt minne för 10 heltal kontinuerligt av typen int och returnerar en pekare till det första elementet i sekvensen, som tilldelas topp (en pekare). p[0] hänvisar till det första elementet, p[1] hänvisar till det andra elementet, och så vidare.

Normal Array-deklaration kontra att använda ny
Det finns en skillnad mellan att deklarera en normal array och att allokera ett minnesblock med nytt. Den viktigaste skillnaden är att normala arrayer avallokeras av kompilatorn (Om arrayen är lokal, avallokeras den när funktionen returnerar eller slutförs). Dynamiskt allokerade arrayer förblir dock alltid där tills de antingen avallokeras av programmeraren eller tills programmet avslutas.

Vad händer om tillräckligt med minne inte är tillgängligt under körning?
Om tillräckligt med minne inte finns tillgängligt i högen för att allokera, indikerar den nya begäran misslyckande genom att kasta ett undantag av typen std::bad_alloc, såvida inte nothrow används med den nya operatorn, i vilket fall den returnerar en NULL-pekare (rulla till avsnittet Undantag hantering av ny operatör i detta artikel). Därför kan det vara en bra idé att kontrollera pekarvariabeln som produceras av den nya innan du använder programmet.

int *p = new(nothrow) int; if (!p) {  cout << 'Memory allocation failed
'; }>

ta bort operatör

Eftersom det är programmerarens ansvar att deallokera dynamiskt allokerat minne, tillhandahålls programmerare raderingsoperator på C++-språk.

Syntax:

// Release memory pointed by pointer-variable   delete   pointer-variable;>

Här är pekarvariabeln pekaren som pekar på dataobjektet som skapats av ny .

Exempel:

delete p; delete q;>

För att frigöra den dynamiskt allokerade matrisen som pekas av pekarevariabeln, använd följande form av radera :

  // Release block of memory     // pointed by pointer-variable  delete[] pointer-variable;     Example:    // It will free the entire array    // pointed by p.   delete[] p;>

// 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; }>

Value of p: 29 Value of r: 75.25 Value store in block of memory: 1 2 3 4 5>

Tidskomplexitet: O(n), där n är den givna minnesstorleken.

stränglängd java

Relaterade artiklar:

• Frågesport om nytt och radera
• radera vs gratis