punteros y referencias

[dacroma]

Buenas noches...
tengo una inquietud acerca de punteros y referencias.
cuando se deben usar y cuando no.

Sè darles uso (referencias para direcciones y punteros para señalar direcciones).

Pero no logro entender mucho, y me temo que cada que quiero ir mas a fondo me
confundo un poco mas solo por que no entiendo cuando darles uso y cuando no.

Saludos.
Gracias

[vangodp]

La diferencia uno de otro es que:
La referencia la debes asignar a la hora de crear.
int &referencia = foo; // ¡Correcto!, no tengo que poner el &delante de foo por que ya se que espera la dirección.
referencia = bar; //(¡INCORRECTO!) No se puede asignar otra dirección, solo a la hora de crear como en el caso antes descrito.

El puntero si puedes "reutilizar":
int *puntero = &bar; // ¡Correcto! Puntero se crea de manera distinta: si veo el * a la hora de crear el puntero debo pasar la & (dirección).
Al igual que la referencia "ambos" (tanto referencia como puntero) esperan la dirección del objeto(variable) a modificar.
puntero = &foobar; // ¡Correcto! Puedo re aprovechar puntero cuantas veces quiera re asignándoles la dirección de otra variable.
Los punteros no son tan cómodos como las referencias pero tienes mucho mas poder.

Digamos que la referencia produce una conexión con la variable y es irrompible "conectas la referencia a la variable cuando creas la referencia", es mas bien como dar un apodo a la variable, los apodos no pueden cambiar de persona ;) ( haces referencia a la variable ).

El puntero es "una variable" que contiene la dirección de otra variable, lo que le permite cambiar a lo que apunta durante su creación y también después de su creación.

El puntero da mucho mas juego que las referencias, pero las referencias pueden llegar a ser mas simples de usar.
Si lo que quiero es pasar algo y esperar que me lo retorne el resultado quizás la referencia por comodidad.
Pero si tengo que apuntar una cosa y después otra el puntero me da mas poder ( Poderes conllevan una gran responsabilidad O.o ¿Donde lo vi? XD).
Las referencias son exclusivas de c++.

[dacroma]

Muchas gracias compañero...
Ahora entiendo un poco mas.

Pero mi otra duda es ¿por que utilizar un puntero que apunte a otro puntero en la estructuracion dinamica?, como por ejemplo.

Código C++:

typedef class  claseLista lista;[COLOR="Green"]//se crea el objeto[/COLOR]
typedef lista *ptrLista;[COLOR="Green"]//se crea un puntero de tipo lista[/COLOR]
 
void ClaseLista::insertar(ptrLista p){
ptrLista nuevo;[COLOR="green"]puntero de tipo ptrLista[/COLOR]
nuevo->p;[COLOR="green"]//puntero que apunta a puntero?[/COLOR]
[COLOR="green"]//resto de la funcion[/COLOR]
}
 

¿por que no puedo hacer una simple autoreferencia y luego usar esa autoreferencia para enlazar los objetos de esa estructura?.

Código C++:

class ClaseLista{
ClaseLista *autoReferencia;[COLOR="green"]//autoreferencia[COLOR="green"]
}
 

[vangodp]

Amigo..... :D
Hay que ser sincero jeje
No llego a tanto XD
Eso ya me supera, a ver si alguien te lo puede explicar mejor que yo.
Solo se que si se puede hacer punteros a punteros a punteros a punteros de forma indefinida.
Solo el que lo creo sabe por que lo hizo así :D
Prueba convertir el programa a tu manera y mira si tiene el mismo efecto ;)
Y esperamos que alguien que tenga mas idea que yo te lo esclarezca el tema. :D
Lo siento

[vangodp]

No se si el tema tiene que ver algo con el puntero this, y aun no eh llegado ahi :D

[dacroma]

Gracias por tu intencion de ayudarme y ...
No te preocupes.

Sin embargo yo sigo con mi indagacion de programacion dinamica.

Hasta luego.

[CalgaryCorpus]

Te conviene mas pensar que los punteros guardan direcciones de memoria, no que guardan otros punteros.

Si piensas que los punteros guardan direcciones de memoria como te propongo, entonces es valido que un puntero guarde la direccion de si mismo, de otro objeto del mismo tipo, de otro objeto de otro tipo, etc. lo que es cierto en C++.

Aunque es cierto que en un puntero se puede guardar cualquier direccion de memoria, lamentablemente no es cierto que despues la puedes usar validamente. Solo es valido y razonable guardar direcciones de memoria de datos tal como definiste el puntero.

Código C++:

int i;
char c;
char *p;
 
p = &c;  // valido y razonable
p = &i;  // valido, pero peligroso, el compilador posiblemente genere un warning
 

Finalmente, cuando tienes 2 nodos distintos en una cola por ejemplo, uno de ellos puede tener como dato un puntero, es decir, guardador de direcciones de memoria, y guardar la direccion de memoria del nodo siguiente, del anterior, del mismo, del ultimo, etc.

El tema es mas largo de explicar, pero creo que esto es la base que necesitas para entender mas.

[dacroma]

Es decir...
Debo poner en mi mente el grafico de una direccion de memoria y que los punteros apuntan es a esas direcciones, en vez de pensar que apuntan es a otros punteros?.

Entiendo un poco mas...

[dacroma]

Código C++:

//Podrian decirme por que no puedo usar la autorefencia de la clase para apuntar
//a un objeto que  quiero insertar  o hacer otra accion, en vez de 
//utilizar una puntero de tipo ptrLista?.
//ejemplo
 
class Lista{
int info;
Lista *sig;
}
void insertar(lista *p,int n){//suponiendo que p apunta al ultimo elemento de la lista
lista nuevo=new (Lista);
nuevo->info=n;
nuevo->sig=Null;
p->sig=nuevo;
p=nuevo;
}
 
 
//EN VEZ DE CREAR UN OBJETO P DE TIPO PUNTERO QUE APUNTE AL PUNTERO DEL 
//ARGUMENTO Y NO A LA AUTOREFERENCIA QUE DECLARÈ EN LA CLASE?
 

[dehm]

Hola:

Si no me equivoco, el motivo por el que no funciona lo que dices es porque estás intentando crear un objeto estático y usarlo. Pero los objetos dentro de la función, como cualquier otra variable, mueren cuando se sale de la función.

Parece que lo intentas arreglar declarando el objeto estático de forma dinámica, con new. No sé si esto compila, pero sigue sin ser un método correcto. El método correcto, es, efectivamente, que el puntero que se crea en la función haga la reserva de memoria y entonces sí existirá esa zona de memoria una vez salgas de la función. De la otra forma, si es que compila, te dará un error de segmentación o algo así.

Veamos:

Código C++:

void insertar(lista *p,int n){//suponiendo que p apunta al ultimo elemento de la lista
lista nuevo;
nuevo.info=n;
nuevo.sig=Null;
p->sig=nuevo;
p=nuevo;
}
 

Primero la función insertar() crea el objeto nuevo. En este paso se hace la reserva de memoria pero como un objeto local a la función.
Luego se le hacen las asigaciones a nuevo.info y a nuevo.sig.
Y por último le das a p la dirección de nuevo.
Pero cuando salgas de la función, el objeto nuevo desaparece, y p apuntará a un sitio no válido.
Otra cosa es si haces:

Código C++:

lista* nuevo=new (Lista);
 

Aunque el puntero desaparece, la reserva de memoria permanece, y si antes de que desaparezca el puntero has enlazado el último elemento de la lista a ese nuevo elemento, la cosa debería de funcionar.
(Otra cosa es que la función insertar() maneja un puntero del tipo lista, lo que no podrás usar para dirigirlo a un objeto del tipo Lista)

No sé si realmente he contestado tu duda. Pero seguro que alguien habrá que te pueda ayudar mejor que yo.

Saludos !

[CalgaryCorpus]

Ademas de lo indicado previamente, en C y C++ el default es el paso por valor, de modo que cualquier función no modifica lo que recibe como parámetro

Código C++:

void f( Tipo v ) {
   v = 4;  // se modifica una copia
}
 
// mas tarde
 
    miVariable = 0;
    f( miVariable );   // se invoca la función "cambiadora", cambia miVariable?
    // miVariable sigue valiendo 0
 

lo que también ocurre con los punteros

Código C++:

void f( Tipo* v ) {
   v = <cualquier expresion>;  // se modifica una copia
}
 

pero si está permitido modificar lo apuntado por los punteros, usándolos a ellos para llegar a los datos

Código C++:

void f( Tipo* v ) {
   v->dato = <cualquier expresion>;  // se modifica el dato!
}
 

La soluciones que se pueden aplicar aquí, para modificar los punteros, pueden ser:
- retornar el puntero e invocar la función de acuerdo a esta definición

Código C++:

T* f( T* v ) 
{
    v = <nueva expresion>;  // no se modifica v
    return v;
}
 
// y luego
     miPuntero = f( miPuntero );
 

- o bien pasar un puntero a puntero y desreferenciarlo al asignar

Código C++:

void f( T** pv ) 
{
    *pv = <nueva expresion>;  // se modifica lo apuntado por v
}
 
 
// y luego
 
    T* puntero;
 
    f( & puntero );
 

En C++ también existe el paso por referencia, pero esto esconde un poco, en el momento de la invocación, el hecho que la función modificará el puntero.

[dacroma]

Ok. Entendì.
Es decir primero tenia que haber reservado memoria para que en ella quepa el objeto que nesecito (LISTA), new (Lista), dinamicamente.

Lo otro es que siempre me queda un poco dificil hacer que el argumento me que apuntando al ultimo elemento de la lista.

[dacroma]

Y estar plenamente seguro de que el argumento es diferente de null.