Geheugen in een C/C++/Java-programma kan op een stapel of op een heap worden toegewezen.
Voorwaarde: Geheugenindeling van C-programma .

Stapeltoewijzing: De toewijzing gebeurt op aaneengesloten geheugenblokken. We noemen het een stapelgeheugentoewijzing omdat de toewijzing plaatsvindt in de functieaanroepstapel. De omvang van het toe te wijzen geheugen is bekend bij de compiler en telkens wanneer een functie wordt aangeroepen, krijgen de variabelen ervan geheugen toegewezen op de stapel. En telkens wanneer de functieaanroep voorbij is, wordt de toewijzing van het geheugen voor de variabelen ongedaan gemaakt. Dit gebeurt allemaal met behulp van enkele vooraf gedefinieerde routines in de compiler. Een programmeur hoeft zich geen zorgen te maken over geheugentoewijzing en het ongedaan maken van de toewijzing van stapelvariabelen. Dit soort geheugentoewijzing wordt ook wel tijdelijke geheugentoewijzing genoemd, omdat zodra de methode de uitvoering beëindigt, alle gegevens die bij die methode horen automatisch uit de stapel worden gespoeld. Dit betekent dat elke waarde die is opgeslagen in het stapelgeheugenschema toegankelijk is zolang de methode de uitvoering ervan niet heeft voltooid en momenteel actief is.

stieren versus os

Belangrijkste punten:

• Het is een tijdelijk geheugentoewijzingsschema waarbij de gegevensleden alleen toegankelijk zijn als de methode( ) die ze bevatte momenteel actief is.
• Het wijst het geheugen automatisch toe of maakt het ongedaan zodra de overeenkomstige methode de uitvoering ervan voltooit.
• We ontvangen de bijbehorende fout Java. lang. StackOverFlowError door JVM , Als het stapelgeheugen volledig gevuld is.
• Toewijzing van stapelgeheugen wordt als veiliger beschouwd in vergelijking met toewijzing van heapgeheugen, omdat de opgeslagen gegevens alleen toegankelijk zijn voor de eigenaarthread.
• Geheugentoewijzing en de-toewijzing zijn sneller in vergelijking met toewijzing van heap-geheugen.
• Stack-geheugen heeft minder opslagruimte in vergelijking met heap-geheugen.

int main() {  // All these variables get memory  // allocated on stack  int a;  int b[10];  int n = 20;  int c[n]; }>

Heap-toewijzing: Het geheugen wordt toegewezen tijdens de uitvoering van instructies die door programmeurs zijn geschreven. Merk op dat de naamheap niets te maken heeft met de geheugenlek kan gebeuren in het programma.

De toewijzing van heap-geheugen is verder onderverdeeld in drie categorieën: - Deze drie categorieën helpen ons bij het prioriteren van de gegevens (Objecten) die moeten worden opgeslagen in het Heap-geheugen of in de Afvalinzameling .

een voorbeeld van een open source besturingssysteem is

• Jonge generatie - Het is het gedeelte van het geheugen waar alle nieuwe gegevens (objecten) worden gemaakt om de ruimte toe te wijzen en wanneer dit geheugen volledig gevuld is, wordt de rest van de gegevens opgeslagen in Garbage Collection.
• Oude of vaste generatie – Dit is het deel van Heap-geheugen dat de oudere dataobjecten bevat die niet of nauwelijks in gebruik zijn.
• Permanente generatie – Dit is het gedeelte van het heap-geheugen dat de metagegevens van de JVM bevat voor de runtimeklassen en toepassingsmethoden.

Belangrijkste punten:

• We ontvangen de bijbehorende foutmelding als Heap-space helemaal vol is, Java. lang.OutOfMemoryError door JVM.
• Dit geheugentoewijzingsschema verschilt van de toewijzing van stapelruimte; hier wordt niet voorzien in een automatische ongedaanmakingsfunctie. We moeten een vuilnisverzamelaar gebruiken om de oude ongebruikte objecten te verwijderen om het geheugen efficiënt te kunnen gebruiken.
• De verwerkingstijd (toegangstijd) van dit geheugen is vrij langzaam in vergelijking met stapelgeheugen.
• Heap-geheugen is ook niet zo threaded-safe als Stack-geheugen, omdat gegevens die zijn opgeslagen in Heap-geheugen zichtbaar zijn voor alle threads.
• De omvang van het Heap-geheugen is behoorlijk groter in vergelijking met het Stack-geheugen.
• Heap-geheugen is toegankelijk of bestaat zolang de hele applicatie (of Java-programma) draait.

int main() {  // This memory for 10 integers  // is allocated on heap.  int *ptr = new int[10]; }>

Gemengd voorbeeld van beide soorten geheugentoewijzing Heap en Stack in Java:

#include  using namespace std; int main() {  int a = 10; // stored in stack  int* p = new int(); // allocate memory in heap  *p = 10;  delete (p);  p = new int[4]; // array in heap allocation  delete[] p;  p = NULL; // free heap  return 0; }>

class Emp {  int id;  String emp_name;  public Emp(int id, String emp_name) {  this.id = id;  this.emp_name = emp_name;  } } public class Emp_detail {  private static Emp Emp_detail(int id, String emp_name) {  return new Emp(id, emp_name);  }  public static void main(String[] args) {  int id = 21;  String name = 'Maddy';  Emp person_ = null;  person_ = Emp_detail(id, name);  } }>

def main(): a = 10 # stored in stack p = None # declaring p variable p = 10 # allocating memory in heap del p # deleting memory allocation in heap p = [None] * 4 # array in heap allocation p = None # free heap return 0 if __name__ == '__main__': main()>

// Define the Emp class with id and emp_name properties class Emp {  constructor(id, emp_name) {  this.id = id; // Initialize id  this.emp_name = emp_name; // Initialize emp_name  } } // Create an instance of the Emp class const person = new Emp(21, 'Maddy'); // Initialize person with id 21 and emp_name 'Maddy' console.log(person); // Output the person object to the console>

Hieronder volgen de conclusies die we zullen trekken na analyse van het bovenstaande voorbeeld:

singleton ontwerppatroon java

• Wanneer we beginnen met de uitvoering van het have-programma, worden alle runtime-klassen opgeslagen in de Heap-geheugenruimte.
• Vervolgens vinden we de methode main() in de volgende regel die in de stapel is opgeslagen, samen met al zijn primitieve (of lokale) en de referentievariabele Emp van het type Emp_detail zal ook in de stapel worden opgeslagen en naar het overeenkomstige object verwijzen opgeslagen in Heap-geheugen.
• Vervolgens roept de volgende regel de geparametriseerde constructor Emp(int, String) aan vanuit main( ) en wordt deze ook toegewezen aan de bovenkant van hetzelfde stapelgeheugenblok. Dit zal opslaan:
  • De objectreferentie van het aangeroepen object van het stapelgeheugen.
  • De primitieve waarde( De referentievariabele van het argument String emp_name verwijst naar de daadwerkelijke tekenreeks uit de tekenreekspool naar het heapgeheugen.
• Vervolgens zal de hoofdmethode opnieuw de statische methode Emp_detail() aanroepen, waarvoor toewijzing zal plaatsvinden in een stapelgeheugenblok bovenop het vorige geheugenblok.
• De referentievariabele van het argument String emp_name verwijst naar de daadwerkelijke tekenreeks uit de tekenreekspool naar het heapgeheugen.

De referentievariabele van het argument String emp_name verwijst naar de daadwerkelijke tekenreeks uit de tekenreekspool naar het heapgeheugen.

Figuur 1

Belangrijkste verschillen tussen stapel- en heaptoewijzingen

1. In een stapel worden de toewijzing en de toewijzing automatisch gedaan door de compiler, terwijl dit in heap handmatig door de programmeur moet worden gedaan.
2. Het hanteren van het Heap-frame is duurder dan het hanteren van het stapelframe.
3. Het probleem met een geheugentekort komt vaker voor in de stapel, terwijl het belangrijkste probleem in het heap-geheugen fragmentatie is.
4. Toegang tot stapelframes is gemakkelijker dan het heapframe, omdat de stapel een klein geheugengebied heeft en cachevriendelijk is, maar in het geval van heapframes die door het geheugen verspreid zijn, veroorzaakt dit meer cachemissers.
5. Een stapel is niet flexibel, de toegewezen geheugengrootte kan niet worden gewijzigd, terwijl een heap flexibel is en het toegewezen geheugen kan worden gewijzigd.
6. Toegang krijgen tot de tijd van heap-takes is meer dan een stapel.

Vergelijkingstabel

Parameter	STAPEL	HOOP
Basis	Geheugen wordt toegewezen in een aaneengesloten blok.	Geheugen wordt in willekeurige volgorde toegewezen.
Toewijzing en de-toewijzing	Automatisch door compilerinstructies.	Handleiding door de programmeur.
Kosten	Minder	Meer
Implementatie	Eenvoudig	Moeilijk
Toegangstijd	Sneller	Langzamer
Hoofdzaak	Tekort aan geheugen	Geheugenfragmentatie
Plaats van referentie	Uitstekend	Adequaat
Veiligheid	Thread safe, opgeslagen gegevens zijn alleen toegankelijk voor de eigenaar	Niet Thread-safe, opgeslagen gegevens zichtbaar voor alle threads
Flexibiliteit	Vast formaat	Het formaat wijzigen is mogelijk
Structuur van gegevenstype	Lineair	Hiërarchisch
Voorkeur	Statische geheugentoewijzing heeft de voorkeur in een array.	Heap-geheugentoewijzing heeft de voorkeur in de gekoppelde lijst.
Maat	Kleiner dan heap-geheugen.	Groter dan stapelgeheugen.