Administración de memoria: Ejemplos

Artigo
06/16/2023

En este artículo se explica cómo MFC realiza asignaciones de marco y de montón para cada uno de los tres tipos típicos de asignaciones de memoria:

Una matriz de bytes
Una estructura de datos
Un objeto

Asignación de una matriz de bytes

Para asignar una matriz de bytes en el marco

Defina la matriz como se muestra en el siguiente código. La matriz se elimina automáticamente y su memoria se reclama cuando la variable de 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

Use el operador new 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

Use el operador delete de la siguiente manera:

delete[] myCharArray;
delete[] myIntArray;

Asignación de una estructura de datos

Para asignar una estructura de datos en el marco

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 reclama cuando sale de su ámbito.

Para asignar estructuras de datos en el montón

Use new para asignar estructuras de datos en el montón y delete para desasignarlas, 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

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

Use el operador new, que devuelve un puntero al objeto, para asignar objetos en el montón. Use el operador delete 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

Compartir por