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

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

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;