Foro de elhacker.net

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..

#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...

ptr_persona = new Estructura[2];

El resto es igual.

Por cierto, pusiste Estrucputa en vez de Estructura.

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:

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.
}

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:

 delete [] (Nombre puntero); 

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

 delete (Nombre puntero); 

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

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