Manejo de memoria en C++

Apuntadores

Declaración 

La sintaxis para declarar una variable apuntador es:

    T *nombre= valor;

Donde:

T: El tipo del dato al que se apunta.

nombre: El nombre de la variable apuntador.

valor: El valor inicial del apuntador (opcional).

int *intPointer = nullptr;

Apuntadores

Operadores

Operador * (Indirección)

Regresa una referencia al contenido del apuntador.

*intPointer = 5;
int number = *intPointer;

Operador -> (Acceso a miembro)

Acceso al miembro de una clase o estructura contenida por un apuntador. Exactamente igual a utilizar "(*T).<miembro de T>"

std::string *name = getName();
int nameLenght = name->size();

Apuntadores

Operadores

Operador & (Dirección de)

Regresa la dirección de memoria del objeto al cual se le aplique el operador en forma de un apuntador. 

std::string name = "Victor";
std::string *namePtr = &name;

Apuntadores

Operadores

Operador new

Este operador crea un nuevo objeto en memoria dinámica y regresa un apuntador al objeto creado. 

double *doublePointer = new double(10.0);

Operador delete

Destruye un objeto en memoria dinámica y libera el espacio de memoria que el objeto ocupaba.

delete doublePointer;

RAII

RAII (Resource Acquisition Is Initialization)

Un objeto debe reservar sus recursos durante la inicialización (Constructor) y liberarlos durante su destrucción (Destructor).

class XmlParser
{
public:
    XmlParser(const std::string &xmlFilePath)
        : xmlFile(new File(xmlFilePath)),
          contents(new ByteArray())
    {
        if (xmlFile->open(File::ReadOnly))
        {
            contents = xmlFile->readAllBytes();
        }
    }

    ~XmlParser()
    {
        if (xmlFile != nullptr && xmlFile->isOpen()) 
        {
            xmlFile->close();
        }
        delete xmlFile;
        delete contents;
    }

    XmlObject parse() { /* Hacer algo con el contenido. */ }

private:
    File *xmlFile;
    ByteArray *contents;
}

RAII

class XmlParser
{
public:
    XmlParser(const std::string &xmlFilePath)
        : xmlFile(new File(xmlFilePath)),
          contents(new ByteArray())
    {
        if (xmlFile->open(File::ReadOnly))
        {
            contents = xmlFile->readAllBytes();
        }
    }

    ~XmlParser()
    {
        if (xmlFile->isOpen()) 
        {
            xmlFile->close();
        }
        delete xmlFile;
        delete contents;
    }

    XmlObject parse() { /* Hacer algo con el contenido. Puede causar excepción. */ }

private:
    File *xmlFile;
    ByteArray *contents;
}

Contenedor de apuntador

template <typename T>
class PointerWrapper
{
public:
    PointerWrapper(T *pointer)
        : pointer(pointer)
    {}

    ~PointerWrapper()
    {
        delete pointer;
    }

    T& operator*() 
    { 
        return *pointer;
    }

    T* operator->() { /* Implementacion */ }
    T& operator=() { /* Implementacion */ }

private:
    T *pointer;
}

Uso del contenedor

class XmlParser
{
public:
    XmlParser(const std::string &xmlFilePath)
        : xmlFile(new File(xmlFilePath)),
          contents(new ByteArray())
    {
        if (xmlFile->open(File::ReadOnly))
        {
            contents = xmlFile->readAllBytes();
        }
    }

    ~XmlParser()
    {
        if (xmlFile->isOpen()) 
        {
            xmlFile->close();
        }
    }

    XmlObject parse() { /* Hacer algo con el contenido. Puede causar excepción. */ }

private:
    PointerWrapper<File> xmlFile;
    PointerWrapper<ByteArray> contents;
}

STL Smart Pointers

Un smart pointer es un contenedor para un apuntador regular que se encarga de eliminar automáticamente el objeto dinámico y liberar la memoria ocupada por el apuntador. Este tipo de apuntadores fueron introducidos en C++11.

std::unique_ptr

Es un apuntador que tiene el control del objeto al que apunta, cuando se destruye la instancia de std::unique_ptr también se destruye el objeto al que apunta. Por lo tanto solo puede haber una sola instancia apuntando al mismo objeto.

void parseXml(const std::string &xmlFilePath)
{
    XmlParser *parser = getParser();
    
    try 
    {
        parser->parse();
        delete parser;
    }
    catch (Exception &e)
    {
        std::cout << e.what();
        delete parser;
    }
}

void parseXml(const std::string &xmlFilePath)
{
    std::unique_ptr<XmlParser> parser(getParser());
    
    try 
    {
        parser->parse();
    }
    catch (Exception &e)
    {
        std::cout << e.what();
    }
}

std::shared_ptr

Este apuntador mantiene un conteo de instancias, el objeto en memoria dinámica se destruye cuando el conteo de instancias llega a cero. Por lo tanto es posible tener muchas instancias de std::shared_ptr apuntando al mismo espacio de memoria.

Ejemplo: std::shared_ptr 

#include <string>

class Cellphone
{
public:
    Cellphone(std::string brand)
        : mBrand(brand)
    {}

    std::string brand() const
    {
        return mBrand;
    }

private:
    std::string mBrand;
};

#include <iostream>
#include <memory>
#include "Cellphone.h"

std::shared_ptr<Cellphone> phoneFactory(std::string brand)
{
    std::shared_ptr<Cellphone> p = 
        make_shared<Cellphone>(brand);
    return p;
}

int main()
{
    auto samsung = phoneFactory("Samsung");
    std::cout << samsung->brand() << std::endl;
}

Cellphone.h

main.cpp