Punteros a estructuras...???

[Ja_90]

Buenas por aqui otra vez jejeje..tratando de resolver dudas...
Estoy aprendidendo y leyendo acerca de los punteros...
Mi duda surge cuando quiero utilizar los punteros con estructuras..

Código (cpp) [Seleccionar] Expandir


#include <iostream>
using std::cout;
using std::cin;
using std::endl;

struct Estructura
{
    string nombre;
    int Edad;
};

int main()
{
   Estructura persona[2];  
 
   Estrucputa *ptr_persona = NULL; // Declaro puntero y lo inicializo

   // Hasta aqui todo va bien, pero como asigno el nombre y la edad que se
   // pida al usuario para llenar el arreglo persona[2]

   // Normalmente sin punteros seria asi:
 
  for (int i=0 ; i<2 ; i++)
  {
      cout << "Ingrese nombre: ";
      getline(cin,persona[i].nombre);
      cout << "Ingrese edad: ";
      cin >> persona[i].edad;
      cin.ignore();
  }

 // Y para imprimirlo seria:

  for (int i=0 ; i<2 ; i++)
  {
      cout << persona[i].nombre << endl;
      cout << persona[i].edad << endl;
  }
}


 Como haria esto con punteros??...Quiero ver como hacerlo con un ejemplo sencillo a ver si
 Puedo lograr algo mas complicado y entender como funcionan los punteros con las estructuras.
 He leido bastante pero no he visto un ejemplo concreto donde pueda ver esto que quiero hacer...

Muchas Gracias a quien me pueda colaborar, ando de autodidacta y no tengo a quien preguntar
en mi entorno acerca de estos temas.

EDITO: Es mediante la asignacion dinamica de memoria (eso creo), seguire leyendo, igualmente si alguien me  puedo dar una breve explicacion lo apreciaria mucho...

[ivancea96]

Código (csharp) [Seleccionar] Expandir

ptr_persona = new Estructura[2];


El resto es igual.

Por cierto, pusiste Estrucputa en vez de Estructura.

[eferion]

Lo que te ha comentado ivancea96 es correcto.

Sin embargo creo que es conveniente hacer una matización:

* Si accedes a una estructura por valor, tienes que usar el operador de miembro '.' para acceder a sus elementos.
* Si accedes a una estructura a través de un puntero, entonces el operador que te permite acceder a los miembros de la estructura es el operador de puntero '->'.

Un ejemplo:

Código (cpp) [Seleccionar] Expandir


struct Estructura
{
  int dato;
};

int main( )
{
  Estructura var1;
  var1.dato = 5; // a var1 accedemos por valor.

  Estructura* ptr = &var1;
  // ptr es un puntero, para acceder al miembro de la estructura tenemos que usar un el operador de puntero
  std::cout << ptr->dato << std::endl;

  Estructura* lista = new Estructura[ 2 ];
 
  // "lista" es un puntero, pero "lista[x]" no, aquí estamos accediendo a la estructura por valor, necesitamos
  // el operador de miembro
  lista[ 0 ].dato = 44;

  Estructura** lista2 = new Estructura*[ 2 ];
  lista2[ 0 ] = new Estructura( );
  lista2[ 1 ] = new Estructura( );

  // "lista2" es un puntero doble, por tanto, "lista2[x]" es un puntero a una estructura. Para acceder a los
  // miembros de dicha estructura necesitamos el operador de puntero.
  lista2[ 0 ]->dato = 85;

  // Faltan los correspondientes "delete" para liberar la memoria reservada, pero no es lo que se
  // está preguntando en este hilo.
}

[Ja_90]

Muchas gracias a ambos por sus respuestas...

eferion respecto a liberar memoria con delete, tengo entendido que siempre se debe realizar para que dicha memoria utilizada se pueda reutilizar por asi decirlo y evitar el desbordamiento (overflow), para asi evitar que el programa colapse. y segun lei se debe hacer asi:

Código (cpp) [Seleccionar] Expandir

delete [] (Nombre puntero);

Estoy en lo correcto?...eso es cuando tengo un arreglo de lo contrario solo seria :

Código (cpp) [Seleccionar] Expandir

delete (Nombre puntero);

[eferion]

lo que creas con new, lo borras con delete y lo que creas con new[] lo tienes que borrar con delete[]:

Código (cpp) [Seleccionar] Expandir


int* ptr = new int;
delete ptr;

ptr = new int[10];
delete[] ptr;