El ciclo de vida de un objeto

El destructor es un método de la clase que se usa para destruir objetos del tipo de la clase, no tiene parámetros de entrada ni valor de retorno. Para declarar un destructor se utiliza el caracter virgulilla (~) seguido del nombre la clase, es decir, el destructor también se denomina del mismo modo que la clase. Los destructores se ejecutan automáticamente justo cuando un objeto alcanza el límite de su tiempo de vida.

Ese tiempo de vida está definido por el contexto (scope) donde se ha declarado el objeto. Un contexto (scope) está delimitado en C++ por las llaves { y }.

Los destructores son especialmente útiles para destruir objetos de almacenamiento dinámico, es decir, aquellos para los que se reserva memoria con ayuda de un apuntador y el operador new.

En el constructor, si yo coloco

Persona(string nombre, int edad) {
      nombre = nombre;
      edad = edad;
    }

Me sale esto:

.
En cambio, si cambio un poco el constructor

Persona(string name, int age) {
      nombre = name;
      edad = age;
    }

Me sale esto:

.
Y si le aplico a this en el constructor

Persona(string nombre, int edad) {
      this->nombre = nombre;
      this->edad = edad;
    }

Me sale esto:

.
En el primer escenario, el nombre de la variable “nombre” es diferente a “name”, y por eso te guarda los datos
.
En el segundo escenario, como ambas son iguales, como que no te capta los datos y por ello no te los guarda (me gustaria saber más acerca de esto, lo que mencione es una deduccion
.
En el tercer escenario, con this accede a las variables directa del objeto y te guarda los datos.
.
Entiendo el por qué del primer y tercer escenario. Pero el segundo Como “wtf? Why? 😦”

Liberar los recursos en el destructor (delete):
Esto es lo que Bjarne Stroustrup definió como RAII (Resource Adquisition Is Initialization) por lo que cada clase es responsable de adquirir recursos y liberarlos para evitar los memory leaks.
En lenguajes como Java no hace falta liberar la memoria en un destructor porque el Garbage Collector se encarga de liberarla.
C++ no tiene GC por lo que es mas eficiente, pero a la vez mas peligroso si no se siguen estas prácticas.

~ <-- Se llama virgulilla y la puedes hacer con : alt + 126

En nuestro destructor liberamos la memoria que reservamos dinámicamente, es decir punteros.

No se preocupen, Diana solo se fue de la sala de chat. 🏃🏻‍♀️

Por ejemplo, en el siguiente código libero el espacio del nombre en el destructor (porque lo implemente como un puntero) 😃:

#include <iostream>
#include <string>

using namespace std;

// Declaracion de la clase Persona
class Persona
{
public:
    string *nombre;

    Persona(string *nombre);
    ~Persona();

    void saludar();
};

// Constructor
Persona::Persona(string *nombre)
{
    this->nombre = nombre;
}

// Destructor
Persona::~Persona()
{
    cout << *nombre << " se ha ido 😢" << endl;
    delete nombre;
}

// Implementacion de saludar
void Persona::saludar()
{
    cout << "Hola soy " << *nombre << " 👋!" << endl;
}

int main()
{
    string *puntero_al_nombre = new string("Diana");
    Persona *p = new Persona(puntero_al_nombre);
    p->saludar();
    delete p;
    cout << "Fin del programa" << endl;
}

Un aporte que es muy bueno ¿Alguien se acuerda del clrscr (limpiar pantalla en algunos lenguajes), para este caso use

system("clear");

Tiene el mismo efecto, úsenlo en los programas les va ayudar

Les dejo el código

#include <iostream>
#include <string>

using namespace std;

class Person {
public:
  string name;
  int age;
  Person(string n, int a) {
    name = n;
    age = a;
  }
  ~Person() { cout << "Destruction" << endl; }
  void say_hi() { cout << name << endl; }
};

int main() {
  Person p = Person("Zero", 14);
  p.say_hi();
}

Ciclo de vida de un objeto:

1. Se reserva un espacio en memoria.
2. Se invoca el constructor. (Función que inicializa todos los valores necesarios dentro del objeto. Los constructores no deben retornar un tipo y deben de tener el mismo nombre que la clase).
3. Periodo de actividad (El objeto existe en memoria durante el tiempo necesario hasta que ya no lo utilicemos).
4. Se invoca al destructor. El destructor viene por defecto en los compiladores, como una función vacía que libera toda la memoria que se reservo. Sin embargo, cuando usamos punteros es bueno hacer nosotros el constructor o utilizar delete para limpiar la memoria dinamica manualmente porque C++ no tiene un recolector de basura como otros lenguajes de Programación.
5. Se libera el espacio de memoria y el compilador asume que esa memoria esta desocupada.

El constructor, si existe, se llama cuando se crea el objeto.
El constructor solo puede ser llamado una sola vez en la vida del objeto.

El destructor, si existe, se llama cuando se borra el objeto.
El destructor puede ser llamado varias veces en la vida del objeto. (para que sirve?..)

#include <iostream>
#include <string>

using namespace std;

class Persona
{
    public: 
        string nombre;
        int edad;

        //constructor 
        Persona(string n, int e)
        {
            nombre = n;
            edad = e;
            cout << "El constructor  fue invocado en persona " << nombre << endl;
        }
        
        // Destructor
        ~Persona()
        {
            cout << "El destructor fue invocado en persona " << nombre << endl;
        }

        void saludar()
        {
            cout << "Hola, mi nombre es: " << nombre << " y tengo: " << edad  << " años" << endl;
        }
};

int main()
{
    Persona p1 = Persona("Maria", 25);
    cout << "nombre: " << p1.nombre << endl;
    cout << "edad:   " << p1.edad << endl;
    p1.saludar();
    cout << endl;

    Persona *p2  = new Persona("Pedro", 38);
    cout << "nombre: " << p2->nombre << endl;
    cout << "edad:   " << p2->edad << endl;
    p2->saludar();
    cout << endl;
    
    delete p2;
   
    p2 = new Persona("Miguel", 41);
    cout << "nombre: " << p2->nombre << endl;
    cout << "edad:   " << p2->edad << endl;
    p2->saludar();
    cout << endl;
    
    Persona *p3;
    p3 = new Persona("Angela",34);
    cout << "nombre: " << p3->nombre << endl;
    cout << "edad:   " << p3->edad << endl;
    p3->saludar();
    cout << endl;

    p1.~Persona();
    p2->~Persona();
    cout << endl;

    cout << "aqui se borra la variable dinamica p2" << endl;
    delete p2;

    cout << "aqui acaban las lineas del programa......" << endl; 
    return 0;
}

Ciclo de vida de un objeto:

1. Se reserva el espacio en memoria.
2. Se invoca el constructor.
3. Período de actividad.
4. Se invoca el destructor.
5. Se libera el espacio en memoria.