Minneshantering: Exempel

Den här artikeln beskriver hur MFC utför ramallokeringar och heap-allokeringar för var och en av de tre typiska typerna av minnesallokeringar:

• En matris med byte

• En datastruktur

• Ett objekt

Allokering av en matris med byte

Så här allokerar du en matris med byte i ramen

1. Definiera matrisen enligt följande kod. Matrisen tas bort automatiskt och dess minne frigörs när matrisvariabeln avslutar sitt omfång.

   {
   const int BUFF_SIZE = 128;
   
   // Allocate on the frame
   char myCharArray[BUFF_SIZE];
   int myIntArray[BUFF_SIZE];
   // Reclaimed when exiting scope 
   }
   

Allokera en matris med byte (eller någon primitiv datatyp) på heapen

1. Använd operatorn new med matrissyntaxen som visas i det här exemplet:

   const int BUFF_SIZE = 128;
   
   // Allocate on the heap
   char* myCharArray = new char[BUFF_SIZE];
   int* myIntArray = new int[BUFF_SIZE];
   

Frigöra arrayerna från heapen

1. Använd delete-operatören på följande sätt:

   delete[] myCharArray;
   delete[] myIntArray;
   

Allokering av en datastruktur

Så här allokerar du en datastruktur i ramen

1. Definiera strukturvariabeln enligt följande:

   struct MyStructType { int topScore; };
   void MyFunc()
   {
      // Frame allocation
      MyStructType myStruct;
   
      // Use the struct 
      myStruct.topScore = 297;
   
      // Reclaimed when exiting scope
   }
   

   Det minne som upptas av strukturen frigörs när strukturen går ur sitt omfång.

Så här allokerar du datastrukturer på heapen

1. Använd new för att allokera datastrukturer på heapen och delete för att deallokera dem, vilket visas i följande exempel:

   // Heap allocation
   MyStructType* myStruct = new MyStructType;
   
   // Use the struct through the pointer ...
   myStruct->topScore = 297;
   
   delete myStruct;
   

Allokering av ett objekt

Så här allokerar du ett objekt i ramen

1. Deklarera objektet på följande sätt:

   {
   CMyClass myClass;     // Automatic constructor call here
   
   myClass.SomeMemberFunction();     // Use the object
   }
   

   Destruktor för objektet anropas automatiskt när objektet lämnar sitt omfång.

Så här allokerar du ett objekt på heapen

1. Använd operatorn new , som returnerar en pekare till objektet, för att allokera objekt på heapen. Använd operatorn delete för att ta bort dem.

   Följande heap- och ramexempel förutsätter att CPerson konstruktorn inte tar några argument.

   // Automatic constructor call here
   CMyClass* myClass = new CMyClass;
   
   myClass->SomeMemberFunction();  // Use the object
   
   delete myClass;  // Destructor invoked during delete
   

   Om argumentet för CPerson konstruktorn är en pekare till charär instruktionen för ramallokering:

   CMyClass myClass("Joe Smith");
   

   Instruktionen för heap-allokering är:

   CMyClass* myClass = new CMyClass("Joe Smith");
   

Se även

Minneshantering: Heap-allokering