Biblioteca de gestión de memoria de C++<memory>

<memory>Es un archivo de cabecera en la biblioteca estándar de C++ que contiene plantillas y funciones para la gestión dinámica de memoria.

En C++, la gestión de memoria es un concepto importante. La gestión dinámica de memoria permite a los programas asignar y liberar memoria en tiempo de ejecución, lo cual es muy útil al tratar con estructuras de datos de tamaño indefinido. Sin embargo, una gestión incorrecta de la memoria puede provocar fugas de memoria, punteros salvajes y otros problemas.

<memory>El archivo de cabecera proporciona herramientas como punteros inteligentes para ayudar a los desarrolladores a gestionar la memoria dinámica de forma más segura.

Punteros inteligentes

Los punteros inteligentes son<memory>el contenido central del archivo de cabecera. Son una característica introducida en C++11 para gestionar automáticamente la memoria asignada dinámicamente. Los principales tipos de punteros inteligentes son:

  • std::unique_ptr: puntero inteligente de propiedad exclusiva; al mismo tiempo solo puede haber ununique_ptrque apunte a una memoria específica.
  • std::shared_ptr: puntero inteligente de propiedad compartida; variosshared_ptrpueden apuntar a la misma memoria, y la memoria se libera cuando el últimoshared_ptrse destruye.
  • std::weak_ptr: puntero inteligente de referencia débil, utilizado parashared_ptrusarse en combinación, evitando fugas de memoria causadas por referencias cíclicas.

Ejemplo

Usostd::unique_ptr

Ejemplo

#include <iostream>
#include <memory>

class MyClass {
public:
    void doSomething() {
        std::cout << "Doing something" << std::endl;
    }
};

int main() {
    std::unique_ptr<MyClass> myPtr(new MyClass());
    myPtr->doSomething(); // Usar puntero inteligente para llamar a la función miembro

    // Cuando la función main termina, myPtr se destruye y libera automáticamente la memoria del objeto MyClass
    return 0;
}

Resultado:

Doing something

Usostd::shared_ptr

Ejemplo

#include <iostream>
#include <memory>

class MyClass {
public:
    void doSomething() {
        std::cout << "Doing something" << std::endl;
    }
};

int main() {
    std::shared_ptr<MyClass> myPtr1(new MyClass());
    std::shared_ptr<MyClass> myPtr2 = myPtr1;

    myPtr1->doSomething(); // Usar myPtr1 para llamar a la función miembro
    myPtr2->doSomething(); // Usar myPtr2 para llamar a la función miembro

    // Cuando myPtr1 y myPtr2 son destruidos, la memoria del objeto MyClass se libera
    return 0;
}

Resultado:

Doing something
Doing something

Usostd::weak_ptr

std::weak_ptrNormalmente no se usa de forma aislada, sino questd::shared_ptrse usa en combinación para resolver el problema de referencias cíclicas.

Ejemplo

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;

    Node() : next(nullptr), prev() {}
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1;

    // Referencia cíclica, pero el uso de weak_ptr evita fugas de memoria
    return 0;
}

En este ejemplo,node1ynode2se forma una referencia cíclica. Debido a esoprevSíweak_ptr, cuandonode1ynode2deshared_ptrse destruyen, la memoria a la que apuntan también se libera correctamente.

Asignador

El asignador es otra parte importante de <memory>.

Los asignadores se utilizan para asignar memoria a los contenedores. Todos los contenedores de la biblioteca estándar usan asignadores para manejar la asignación de memoria.

std::allocator

std::allocator es el asignador estándar y proporciona funciones básicas de asignación y liberación de memoria.

Ejemplo

#include <memory>
#include <vector>

int main() {
    std::allocator<int> alloc;
    int* p = alloc.allocate(1); // Asignar memoria
    alloc.construct(p, 42); // Construir objeto

    std::cout << *p << std::endl;

    alloc.destroy(p); // Destruir objeto
    alloc.deallocate(p, 1); // Liberar memoria

    return 0;
}

Otras herramientas de gestión de memoria

std::align

std::align se utiliza para ajustar la alineación de los punteros, asegurando que la memoria asignada cumpla con requisitos de alineación específicos.

Ejemplo

#include <memory>
#include <iostream>

int main() {
    alignas(16) char buffer[64];
    void* p = buffer;
    size_t space = sizeof(buffer);

    void* aligned_ptr = std::align(16, sizeof(int), p, space);
    if (aligned_ptr) {
        std::cout << "Memory aligned\n";
    } else {
        std::cout << "Memory alignment failed\n";
    }

    return 0;
}

<memory>El archivo de cabecera es una parte importante de la biblioteca estándar de C++ que se encarga de la gestión dinámica de memoria.

Al usar punteros inteligentes, comounique_ptr、shared_ptryweak_ptr, los desarrolladores pueden gestionar la memoria de manera más segura y eficiente, evitando errores comunes de gestión de memoria. Espero que este artículo ayude a los principiantes a comprender y usar mejor el<memory>archivo de cabecera de C++.

Otras extensiones