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;