Administración de memoria: ejemplos

En este artículo se describe cómo MFC realiza asignaciones de marcos y asignaciones de pila para cada uno de los tres tipos típicos de asignaciones de memoria:

• Matriz de bytes

• Estructura de datos

• Un objeto

Asignación de una matriz de bytes

Para asignar una matriz de bytes en el marco

1. Defina la matriz como se muestra en el código siguiente. La matriz se elimina automáticamente y su memoria se recupera cuando la variable de la matriz sale de su ámbito.

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

Para asignar una matriz de bytes (o cualquier tipo de datos primitivo) en el montón

1. Use el new operador con la sintaxis de matriz que se muestra en este ejemplo:

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

Para desasignar las matrices del montón

1. Use el operador delete como se indica a continuación:

   delete[] myCharArray;
   delete[] myIntArray;
   

Asignación de una estructura de datos

Para asignar una estructura de datos en el marco

1. Defina la variable de estructura de la siguiente manera:

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

   La memoria ocupada por la estructura se recupera cuando sale de su ámbito.

Para asignar estructuras de datos en el montón

1. Use new para asignar estructuras de datos en el montón y delete desasignarlos, como se muestra en los ejemplos siguientes:

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

Asignación de un objeto

Para asignar un objeto en el marco

1. Declare el objeto de la siguiente manera:

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

   El destructor del objeto se invoca automáticamente cuando el objeto sale de su ámbito.

Para asignar un objeto en el montón

1. Utilice el new operador , que devuelve un puntero al objeto , para asignar objetos en el montón. Use el delete operador para eliminarlos.

   En los siguientes ejemplos de montón y marco se da por hecho que el constructor CPerson no toma ningún argumento.

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

   Si el argumento del constructor CPerson es un puntero a char, la instrucción para la asignación del marco es:

   CMyClass myClass("Joe Smith");
   

   La instrucción para la asignación del montón es:

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

Consulte también

Administración de memoria: asignación del montón