Creando nuestra primera estructura

Cuando creamos una variable así:

Persona p = Persona();

Lo que hace el compilador es que aparta un espacio de memoria del tamaño necesario para almacenar una estructura que contenga un nombre y una edad.

A ese espacio le llamamos “p”, y de hecho como ahí aún no le ponemos valores, están vacíos en la memoria.

Cuando creamos una variable así:

Persona *p = new Persona();

Lo que hacemos antes del “=”, es NO reservar un espacio de memoria para almacenar una persona, simplemente creamos una variable “p” que puede almacenar una dirección de memoria, y le decimos que almacenará de hecho una dirección que apuntará a una persona más adelante.

Luego, cuando llega al “new Persona()”, que de hecho ese ya se ejecuta cuando ejecutamos el programa, no cuando compilamos, lo que pasará es que ahí si, apartará en memoria un espacio suficiente para almacenar una persona, obtendrá su puntero, y ese puntero será el que almacenará en p.

Por lo tanto no son exactamente iguales, aunque para fines prácticos puedan ser equivalentes, internamente C++ los maneja distinto, y podemos utilizar uno u otro según lo que necesitemos más adelante.

Persona p = Persona();

Crea un objeto del tipo Persona en el stack de manera estática (al tiempo de compilación), mientras que:

Persona *p = new Persona();

Crea un objeto del tipo Persona en el heap de manera dinámica (al tiempo de ejecución)
La memoria dinamica que reservamos con new en el heap, debemos liberarla para no generar memory leaks o pérdidas de memoria. Para liberar un objeto reservado con new se utiliza:

delete p;

una vez que ya no lo necesitamos mas al objeto.

Les dejo el codigó de la clase usando un metodo constructor en la struct 😃

#include <iostream>
#include <string>

using namespace std;

struct Person {
  string name;
  int age;

  // Constructor
  Person(string n, int a) {
    name = n;
    age = a;
  }
};

int main() {
  // Traditional way
  Person zero = Person("Eliaz", 14);
  cout << zero.name << endl;

  // Dynamic gestion of memory
  Person *p = new Person("Zero Requiem", 14);
  cout << p->age << endl;
}

Si quiere ver el resto de mi codigó les dejo el repositorio aquí.

Pequeño resumen

int main()
{
  // Se reserva al compilar
  Persona p = Persona();
  p.nombre = "Diana";
  p.edad = 26;
  cout << p.nombre << endl;
  cout << p.edad << endl;

  // Gestiona la memoria de forma dinámica
  Persona *a = new Persona();
  a->nombre = "Diana";
  a->edad = 26;
  cout << a->nombre << endl;
  cout << a->edad << endl;
}

Una analogía sencilla y tonta para comprender la diferencia entre la asignación de memoria dinámica y estática a las instancias de una clase sería:

Estática:
Ordenar un plato de comida en un restaurant cuando se te solicita tu orden por primera vez. (se te asigna un platillo ANTES de que te traigan tu orden)

Dinámica:
Ordenar un plato de comida cuando se te solicita retirarte del restaurant por no ordenar nada. (se te asigna un platillo CUANDO debes decidir pedir tu orden)

Nota: En el contexto del restaurant siempre estarán dispuestos a asignarte un plantillo.

Dejo el código que hice con notas sobre la clase.

#include <iostream>

using namespace std;

struct Persona
{
    string nombre;
    int edad;
};


int main(int argc, char const *argv[])
{
                  
    /*
    Sin punteros
    Desde el proceso de compilación se crea la
    variable de tipo Persona y 
    reserva su memoria
    */
    Persona p = Persona();
    p.nombre = "Ana";
    p.edad = 18;
    cout <<"Se llama " << p.nombre << " y tiene " << p.edad << " años" <<endl ;

    /*
    Con punteros
    Se hace por Memoria Dinámica
    La variable de tipo Persona se crea durante la ejecución 
    */
    Persona *p_2 = new Persona();   //Se usa la palabra reservada 'new'
    p_2-> nombre = "Bruno";         //Se utiliza la notación de flecha
    p_2-> edad = 17;
    cout <<"Se llama " << p_2->nombre << " y tiene " << p_2->edad << " años" <<endl ;

    //Tamaño
    cout << "El tamaño de p es: "<< sizeof(p) << endl;
    cout << "El tamaño de p.nombre es: "<< sizeof(p.nombre) << endl;
    cout << "El tamaño de p.edad es: " << sizeof(p.edad) << endl;

    
    return 0;
}

Ejemplo de clase:

#include <iostream>
#include <string>

using namespace std;

struct Person {
  string name;
  int age;
};

int main() {

  // memory is assigned dinamically (execution time)
  Person *somePerson2 = new Person();
  somePerson2->name = "Anders2";
  // class member and object memory adress
  cout << &somePerson2->name << endl;
  cout << somePerson2 << endl;

  // class member value
  cout << somePerson2->name << endl;

  // memory is assigned statically (compilation time)
  Person somePerson = Person();
  somePerson.name = "Anders";
  cout << somePerson.name << endl;
}

La única diferencia que encontré entre inicializar y no inicalizar Persona p es que

• Al inicializarlo te da valores nulos por defecto, para nombre te da un valor vacio y para edad te da el valor de 0
• Al no iniciarlo, con nombre pasa lo mismo, pero con edad te da un “valor random” por defecto.

Digo “random” porque en mi caso siempre me lo inicializaba con 8.

Al inicializar los miembors de la estructura Persona no encontré ninguna diferencia; ambos casos te dan los valores definidos en la estructura.

Si les interesa entender un poco mas la ultima tabla que se muestra en clase entren a este link! ✨

Les comparto lo que pude realizar, en esta clase:

#include <iostream>
#include <string>

using namespace std;

struct persona {
    string nombre;
    int edad;
    
};

int main () {
    persona *p = new persona();
    p->nombre = "Nelson";
    p->edad = 16;

    cout << p->nombre << endl << p->edad;

}

esto es como se forma la estructura

<code> 
#include <iostream>
using namespace std;

struct persona
{
    string nombre;
    int edad;

};//se debe coloacar al terminar una esxtructura ; al final de la llave


int main()
{
    
    persona *p = new persona();
    p->nombre = "clon54";
    p->edad = 26;
    cout << p->nombre<<endl;
    cout << p->edad;
 //-> son porque usamos puneteros asi sabe el compilador donde bucar en memoria
}

Complementando la inicialización por asignación de memoria en tiempo de compilación:

Persona p = { "Diana", 26 };

En esta sintaxis es importante escribir los valores en el orden en que fueron declaradas las propiedades de la estructura.

Waao no sabia que se podia hacer esto con los struct

Cada pasito mas cerca de terminar la carrera!