Autor Tema: Puntero A Punteros (Leído 8612 veces)

AnioN · « **en:** Jueves 29 de Marzo de 2007, 21:32 »

Hola, tengo una duda con el tema que no puedo lograr entender.

Por ej en este cidigo:

Código: Text

#include &#60;stdio.h&#62;
#include &#60;string.h&#62;
#include&#60;stdlib.h&#62;
 
 
int main()
{
  char **cpp;
  char *cp;
  char c = 'a';
 
  cp = &c;
 
  cpp = &cp;
 
  printf(&#34;%c&#092;n&#34;, c);
  printf(&#34;%x&#092;n&#34;, &c);
 
  printf(&#34;%p&#092;n&#34;, &cpp); // que diferencia hay entre esta linea y
  printf(&#34;%p&#092;n&#34;, cpp);   //  esta 
 
 
  return 0;
}
 
 

Bicholey

En una retornas el valor de cpp y en otra lo que contiene la direccion de cpp

AnioN

Cita de: "Bicholey"

En una retornas el valor de cpp y en otra lo que contiene la direccion de cpp

o sea, la segunda linea muestra donde apunta el puntero a puntero?

Código: Text

#include &#60;stdio.h&#62;
#include &#60;string.h&#62;
#include&#60;stdlib.h&#62;
 
 
int main()
{
 char **cpp;
 char *cp;
 char c = 'a';
 
 cp = &c;
 
 cpp = &cp;
 
 printf(&#34;%c&#092;n&#34;, c);
 printf(&#34;%x&#092;n&#34;, &c);
 
 printf(&#34;%p&#092;n&#34;, &cpp); 
 printf(&#34;%p&#092;n&#34;, cpp);   //  esta es equivalente a  printf(&#34;%x&#092;n&#34;, &cp);
 
 return 0;
}
 

AnioN

otra duda es, con este codigo:

Código: Text

 
 float **float_values;
 float_values = (float**)malloc(4 *sizeof(float*));

Ahi lo que hace es crear 4 punteros en forma dinamica, no?, y si quiero crear en forma dinamica 4 punteros a punteros?

JuanK

Código: Text

  float ***float_values;
float_values = (float***)malloc(4 *sizeof(float**));
 

desde luego los punteros ** estan sin inicializar.

AnioN

o sea podes almacenar 4 punteros no? con esto?

float **float_values;
float_values = (float**)malloc(4 *sizeof(float*));

JuanK

Eternal Idol

Código: Text

 
printf(&#34;%p&#092;n&#34;, &cpp); // que diferencia hay entre esta linea y
printf(&#34;%p&#092;n&#34;, cpp);   //  esta

La primera obtiene la direccion en memoria de la variable local cpp y la segunda su contenido (el primer puntero por decirlo de alguna manera). Si queres obtener el doble puntero tenes que desreferenciar la variable cpp y eso se hace con el *, eso te daria la direccion de c y con doble ** obtendrias el valor de c.

Cita de: "AnioN"

otra duda es, con este codigo:

Ahi lo que hace es crear 4 punteros en forma dinamica, no?, y si quiero crear en forma dinamica 4 punteros a punteros?

No, lo que hace es reservar 16 bytes de memoria y asignarselos a float_values, exactamente asi es como normalmente se hace con dobles punteros.

Código: Text

 
float **float_values;
float_values = (float**)malloc(4 *sizeof(float*));
for (int x= 0; x &#60; 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
*float_values[0] = 3.51;
*float_values[1] = 4.62;
*float_values[2] = 5.73;
*float_values[3] = 6.84;
for (int x= 0; x &#60; 4; x++) { printf(&#34;%f&#092;r&#092;n&#34;, *float_values[x]); }
for (int x= 0; x &#60; 4; x++) {  free(float_values[x]); }
free(float_values);
 
 

AnioN

Cita de: "JuanK"

SI

entonces la forma que mencionas para crear 4 punteros a punteros es erronea, o me equivoco?

JuanK

Cita de: "AnioN"

Cita de: "JuanK"
SI
entonces la forma que mencionas para crear 4 punteros a punteros es erronea, o me equivoco?

que son capaces de apuntar a 4 punteros.

float_values = (float***)malloc(4 *sizeof(float**));

pero sin inicializar, es decir apuntando a cualquier cosa.

Cita de: "Eternal Idol"

No, lo que hace es reservar 16 bytes de memoria y asignarselos a float_values, exactamente asi es como normalmente se hace con dobles punteros.

Se reserva la memoria nada mas, lo cual, y gracias al cast, es un array de punteros sin inicializar.

AnioN

no te entiendo que es lo que queres decir, podes ser un poco mas claro?. Si me decis que con esto se puedel almacenar 4 punteros entonces son punteros a punteros.

float **float_values;
float_values = (float**)malloc(4 *sizeof(float*));

y que estarias haciendo con esto?
float_values = (float***)malloc(4 *sizeof(float**));

Eternal Idol

Cita de: "JuanK"

float_values = (float***)malloc(4 *sizeof(float**));

Eso es un triple puntero ...

Código: Text

 
float ***float_values = (float***)malloc(4 *sizeof(float**));
float_values[0] = (float**)malloc(sizeof(float) * 56);
float_values[0][54] = (float*)malloc(sizeof(float));
*float_values[0][54] = 3.53;

Cita de: "JuanK"

Se reserva la memoria nada mas, lo cual, y gracias al cast, es un array de punteros sin inicializar.

Tambien se le asigna a la variable local float_values el valor devuelto por malloc, para eso esta el cast sino daria error al no coincidir los tipos en la asignacion.

JuanK

Cita de: "AnioN"

y que estarias haciendo con esto?
float_values = (float***)malloc(4 *sizeof(float**));

reservar memoria direccionada por un triple puntero, esa memoria sirve para guardar 4 punteros a punteros.

se lee, un apuntador que apunta a una coleccion de apuntadores a apuntadores.

Código: Text

float **float_values;
float_values = (float**)malloc(4 *sizeof(float*));
 

esto es reservar memoria que se direcciona con un doble puntero, esa memoria sirve para guardar 4 punteros.

se lee, un apuntador que apunta a una coleccion de apuntadores.

Eternal Idol

AnioN mira el codigo que te deje y sino mira esto:
http://www.codeproject.com/useritems/pointertopointer.asp
http://www.eskimo.com/~scs/cclass/int/sx8.html

Esto es un puntero: char *
Esto es un puntero a un puntero (doble puntero): char **
Esto es un puntero a un puntero a un puntero (triple puntero): char ***

JuanK

Pues yo no se, pero para mi que estamos hablando de lo mismo:

Enko

Por esa casualidad, el tamaño de un puntero y de un puntero a puntero no es el mismo?

Código: Text

 
sizeof(**float) == sizeof(***float)

Eternal Idol

Cita de: "JuanK"

Pues yo no se, pero para mi que estamos hablando de lo mismo:

¿Vos ves que alguien use triple puntero para esto en algun lado? Esa pagina lo unico que demuestra es que ni siquiera para varias dimensiones se necesita el triple puntero.

Cita de: "Enko"

Por esa casualidad, el tamaño de un puntero y de un puntero a puntero no es el mismo?
Código: Text

sizeof(**float) == sizeof(***float)

Obvio jeje, no es mas que una direccion de memoria, en x86 4 bytes/32 bits y en x86-64 8bytes/64bits.

JuanK

Citar

¿Vos ves que alguien use triple puntero para esto en algun lado? Esa pagina lo unico que demuestra es que ni siquiera para varias dimensiones se necesita el triple puntero.

pues lo que yo veo es aca:

http://www.codeproject.com/useritems/pointertopointer.asp

usan un doble puntero para acceder a un array de 'dos dimensiones', lo cual es tal cual lo que he dicho

Desde luego que incluso sin necesidad de eso se puede 'emular' un array bidimensional usando aritmética, pero eso es otra cosa.

Y en esta otra

http://www.eskimo.com/~scs/cclass/int/sx8.html

lo único que dicen de dimensiones es:

Citar

Another good use for pointers to pointers is in dynamically allocated, simulated multidimensional arrays, which we'll discuss in the next chapter.

Independientemente de en que se use

un triple puntero es un puntero a una coleccion de punteros a punteros.

y es muy simple de ver ya que si un ** es un array de 2d un nuevo puntero lo convierte en un array de 3d .

El cual inicialmente se inicia asi:

Código: Text

float_values = (float***)malloc(4 *sizeof(float**));
 

ya luego hay necesidad de iniciar sus miembros 2d cada uno con:

Código: Text

(float**)malloc(4 *sizeof(float*));
 

etc.

Citar

Por esa casualidad, el tamaño de un puntero y de un puntero a puntero no es el mismo?
CODE

sizeof(**float) == sizeof(***float)

asi es, en el codigo se indica el nivel de indirección solo por razones de legibilidad .

Por cierto el codigo que has colocado tiene los punteros a la izquierda y debe ser a la derecha del tipo.

Citar

sizeof(**float) == sizeof(***float)

Eternal Idol

Como quieras, que yo sepa esto empezo por tu insistencia en la necesidad de usar un triple puntero cuando el codigo de AnioN usaba un doble puntero, segun yo y otras personas para reservar cuatro punteros a puntero no necesitas un triple puntero, ahi deje un ejemplo y en las paginas hay otro. Es todo lo que tengo que decir al respecto.

JuanK

Cita de: "AnioN"

otra duda es, con este codigo:

Código: Text

float **float_values;
float_values = (float**)malloc(4 *sizeof(float*));

Ahi lo que hace es crear 4 punteros en forma dinamica, no?, y si quiero crear en forma dinamica 4 punteros a punteros?

mm bueno yo solo estaba contestando a esto.

Citar

segun yo y otras personas para reservar cuatro punteros a puntero no necesitas un triple puntero

Claro que no, eso es solo una forma de hacerlo y permite acceder al contenido como un array de 3 dimensiones. [][][]

AnioN

cada vez entiendo menos, a ver, vamos por partes.

Segun esto:

Código: Text

 
          float **float_values;
 
     //allocate memory for rows
 
     float_values = (float**)malloc(4 *sizeof(float*));

Con esto se estarian creando 4 punteros?

JuanK

Bingo, se están creando aunque no se ha inicializado.

Para ser mas exactos se ha creado un puntero y se ha reservado memoria para 4 punteros mas, es decir tienes un puntero que puede apuntar a uno de los otros 4 a la vez, que es lo que he dicho siempre y lo mismo que eternal idol ha dicho.

Cita de: "AnioN"

y si quiero crear en forma dinamica 4 punteros a punteros?

Teniendo en cuenta que estabas preguntando acerca de la forma:

Código: Text

   float_values = (float**)malloc(4 *sizeof(float*));
 

Para crear un cuatro punteros a puntero puedes hacerlo de mucha formas, y sobre todo dependiendo del uso que le quieras dar, pero con base al contexto de tu pregunta lo que debes hacer es lo que te sugiero:

Código: Text

float ***float_values;
float_values = (float***)malloc(4 *sizeof(float**));
 

esto SI te crea lo que tu mencionabas es decir 4 punteros a punteros, y tal como dije antes aun hace falta inicializar las otras dimensiones del array de 3 dimensiones (si lo quieres ver asi).

Esto describe mas gráficamente de lo que estoy hablando y es un ejemplo de lo que se puede hacer:

Eternal Idol

El primer grafico no representa lo que yo le dije que hiciera, te lo dejo con el codigo y tal vez lo entiendas. Hay cuatro direcciones de memoria (punteros float **) reservadas con la primera linea del codigo y estas apuntan a otras cuatro direcciones de memoria (punteros float *) reservadas en un bucle en la segunda linea. Por lo tanto tenemos 4 PUNTEROS (float **) A PUNTEROS (float*) que apuntan a cuatro valores distintos asignados en las lineas siguientes. Posteriormente vemos los valores en pantalla y liberamos primero los cuatro float * y despues los cuatro float **. ¿No es lo que muestra tu grafico, no? Eso es un puntero a puntero, eso es lo que pidio AnioN y lo que vos propones es un PUNTERO, A PUNTERO, A PUNTERO (TRIPLE PUNTERO) que obviamente contiene un PUNTERO A PUNTERO (DOBLE PUNTERO) que es lo que yo propongo. Considero entonces que estas dando una solucion mas compleja que el problema planteado.

Código: Text

 
float **float_values = (float**)malloc(4 *sizeof(float*));
for (int x= 0; x &#60; 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
*float_values[0] = 3.51;
*float_values[1] = 4.62;
*float_values[2] = 5.73;
*float_values[3] = 6.84;
for (int x= 0; x &#60; 4; x++) { printf(&#34;%f&#092;r&#092;n&#34;, *float_values[x]); }
for (int x= 0; x &#60; 4; x++) {  free(float_values[x]); }
free(float_values);
 
 

Este grafico si representa mi codigo:

Notese que puedo acceder a los datos con dos indirecciones, por algo sera, es un puntero a un puntero. ¿AnioN te parece que lo que vos querias era eso que dice JuanK? JuanK hacenos el favor y mostranos tu codigo completo que sirva para trabajar con 4 punteros a punteros.

AnioN

Cita de: "Eternal Idol"

El primer grafico no representa lo que yo le dije que hiciera, te lo dejo con el codigo y tal vez lo entiendas. Hay cuatro direcciones de memoria (punteros float **) reservadas con la primera linea del codigo y estas apuntan a otras cuatro direcciones de memoria (punteros float *) reservadas en un bucle en la segunda linea. Por lo tanto tenemos 4 PUNTEROS (float **) A PUNTEROS (float*) que apuntan a cuatro valores distintos asignados en las lineas siguientes. Posteriormente vemos los valores en pantalla y liberamos primero los cuatro float * y despues los cuatro float **. ¿No es lo que muestra tu grafico, no? Eso es un puntero a puntero, eso es lo que pidio AnioN y lo que vos propones es un PUNTERO, A PUNTERO, A PUNTERO (TRIPLE PUNTERO) que obviamente contiene un PUNTERO A PUNTERO (DOBLE PUNTERO) que es lo que yo propongo. Considero entonces que estas dando una solucion mas compleja que el problema planteado.

Código: Text

float **float_value s= float_values = (float**)malloc(4 *sizeof(float*));
for (int x= 0; x < 4; x++) { float_values[x] = (float*)malloc(sizeof(float)); }
*float_values[0] = 3.51;
*float_values[1] = 4.62;
*float_values[2] = 5.73;
*float_values[3] = 6.84;
for (int x= 0; x < 4; x++) { printf("%f\r\n", *float_values[x]); }
for (int x= 0; x < 4; x++) { free(float_values[x]); }
free(float_values);

Este grafico si representa mi codigo:

Notese que puedo acceder a los datos con dos indirecciones, por algo sera, es un puntero a un puntero. ¿AnioN te parece que lo que vos querias era eso que dice JuanK? JuanK hacenos el favor y mostranos tu codigo completo que sirva para trabajar con 4 punteros a punteros.

si es como decis, en la primera linea reservas memoria para los dobles punteros, en el bucle para los punteros pero donde reservas para las variables que apuntan los punteros?
No entiendo que hace la s.

Código: Text

float **float_value s= float_values = (float**)malloc(4 *sizeof(float*));
 

Eternal Idol

Cita de: "AnioN"

si es como decis, en la primera linea reservas memoria para los dobles punteros, en el bucle para los punteros pero donde reservas para las variables que apuntan los punteros?

Variable tenemos siempre una sola: float_values, a esta le asignamos la direccion de memoria que nos devuelve el primer malloc y cuyo tamaño es de 16 bytes (de memoria contigua):

float_values es igual a DIR0 que al principio es:
DIR0: INDEFINIDO
DIR1: INDEFINIDO
DIR2: INDEFINIDO
DIR3: INDEFINIDO

Entonces hacemos un bucle donde asignamos eso con punteros a otra memoria reservada para cada uno del tamaño necesario.

DIR0: float *
DIR1: float *
DIR2: float *
DIR3: float *

Tenemos entonces que float_values[X] apunta a un float *, es un puntero que apunta a un puntero, no a un valor, es un doble puntero. Por eso para poder obtener el valor tenemos que hacer *float_values

. Si hacemos *float_values obtenemos DIR0 (ES UN PUNTERO QUE APUNTA A UN PUNTERO) y si hacemos **float_values obtenemos *DIR0 que en este caso es el float cuyo valor es 3.51, podes verlo asi:

Código: Text

 
float **float_values = (float**)malloc(4 *sizeof(float*));
ZeroMemory(float_values, 4 *sizeof(float*));
printf(&#34;%p&#092;r&#092;n&#34;, *float_values);
for (int x= 0; x &#60; 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
printf(&#34;%p&#092;r&#092;n&#34;, *float_values);
 
 

En vez de tener memoria indefinida ahora sabemos que tenemos cuatro punteros nulos al usar ZeroMemory (una simplificacion de memset) sobre toda la memoria. Primero vemos que *float_values (equivalente a float_values[0]) es justamente 0, apunta a 0 y despues es igual a lo que devuelva malloc. Lo mismo pasa con los otras 3 siguientes direcciones de memoria, primero seran punteros nulos y despues punteros a float.

Cita de: "AnioN"

No entiendo que hace la s.

Nada, problemas de copy + paste, ahi lo cambie.