SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: AnioN en Jueves 29 de Marzo de 2007, 21:32

Título: Puntero A Punteros
Publicado por: 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
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include<stdlib.h>
  4.  
  5.  
  6. int main()
  7. {
  8.   char **cpp;
  9.   char *cp;
  10.   char c = 'a';
  11.  
  12.   cp = &c;
  13.  
  14.   cpp = &cp;
  15.  
  16.   printf("%c\n", c);
  17.   printf("%x\n", &c);
  18.  
  19.   printf("%p\n", &cpp); // que diferencia hay entre esta linea y
  20.   printf("%p\n", cpp);   //  esta
  21.  
  22.  
  23.   return 0;
  24. }
  25.  
  26.  
Título: Re: Puntero A Punteros
Publicado por: Bicholey en Jueves 29 de Marzo de 2007, 21:37
:P  :P  :P  :P


En una retornas el valor de cpp y en otra lo que contiene la direccion de cpp
Título: Re: Puntero A Punteros
Publicado por: AnioN en Jueves 29 de Marzo de 2007, 21:40
Cita de: "Bicholey"
:P  :P  :P  :P


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
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include<stdlib.h>
  4.  
  5.  
  6. int main()
  7. {
  8.  char **cpp;
  9.  char *cp;
  10.  char c = 'a';
  11.  
  12.  cp = &c;
  13.  
  14.  cpp = &cp;
  15.  
  16.  printf("%c\n", c);
  17.  printf("%x\n", &c);
  18.  
  19.  printf("%p\n", &cpp);
  20.  printf("%p\n", cpp);   //  esta es equivalente a  printf("%x\n", &cp);
  21.  
  22.  return 0;
  23. }
  24.  
Título: Re: Puntero A Punteros
Publicado por: AnioN en Jueves 29 de Marzo de 2007, 21:55
otra duda es, con este codigo:

Código: Text
  1.  
  2.  float **float_values;
  3.  float_values = (float**)malloc(4 *sizeof(float*));
  4.  

Ahi lo que hace es crear 4 punteros en forma dinamica, no?, y si quiero crear en forma dinamica 4 punteros a punteros?
Título: Re: Puntero A Punteros
Publicado por: JuanK en Jueves 29 de Marzo de 2007, 22:02
Código: Text
  1.   float ***float_values;
  2. float_values = (float***)malloc(4 *sizeof(float**));
  3.  

desde luego los punteros ** estan sin inicializar.
Título: Re: Puntero A Punteros
Publicado por: AnioN en Jueves 29 de Marzo de 2007, 22:50
o sea podes almacenar 4 punteros no? con esto?

float **float_values;
float_values = (float**)malloc(4 *sizeof(float*));
Título: Re: Puntero A Punteros
Publicado por: JuanK en Jueves 29 de Marzo de 2007, 22:52
SI
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Jueves 29 de Marzo de 2007, 22:53
Código: Text
  1.  
  2. printf("%p\n", &cpp); // que diferencia hay entre esta linea y
  3. printf("%p\n", cpp);   //  esta
  4.  
  5.  

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
  1.  
  2. float **float_values;
  3. float_values = (float**)malloc(4 *sizeof(float*));
  4. for (int x= 0; x < 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
  5. *float_values[0] = 3.51;
  6. *float_values[1] = 4.62;
  7. *float_values[2] = 5.73;
  8. *float_values[3] = 6.84;
  9. for (int x= 0; x < 4; x++) { printf("%f\r\n", *float_values[x]); }
  10. for (int x= 0; x < 4; x++) {  free(float_values[x]); }
  11. free(float_values);
  12.  
  13.  
Título: Re: Puntero A Punteros
Publicado por: AnioN en Jueves 29 de Marzo de 2007, 22:53
Cita de: "JuanK"
SI
entonces la forma que mencionas para crear 4 punteros a punteros es erronea, o me equivoco?
Título: Re: Puntero A Punteros
Publicado por: JuanK en Jueves 29 de Marzo de 2007, 23:05
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.
Título: Re: Puntero A Punteros
Publicado por: AnioN en Jueves 29 de Marzo de 2007, 23:09
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**));
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Jueves 29 de Marzo de 2007, 23:13
Cita de: "JuanK"
float_values = (float***)malloc(4 *sizeof(float**));

Eso es un triple puntero ...

Código: Text
  1.  
  2. float ***float_values = (float***)malloc(4 *sizeof(float**));
  3. float_values[0] = (float**)malloc(sizeof(float) * 56);
  4. float_values[0][54] = (float*)malloc(sizeof(float));
  5. *float_values[0][54] = 3.53;
  6.  
  7.  

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.
Título: Re: Puntero A Punteros
Publicado por: JuanK en Jueves 29 de Marzo de 2007, 23:20
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
  1. float **float_values;
  2. float_values = (float**)malloc(4 *sizeof(float*));
  3.  

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.
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Jueves 29 de Marzo de 2007, 23:25
AnioN mira el codigo que te deje y sino mira esto:
http://www.codeproject.com/useritems/pointertopointer.asp (http://www.codeproject.com/useritems/pointertopointer.asp)
http://www.eskimo.com/~scs/cclass/int/sx8.html (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 ***
Título: Re: Puntero A Punteros
Publicado por: JuanK en Jueves 29 de Marzo de 2007, 23:40
Pues yo no se, pero para mi que estamos hablando de lo mismo:

(http://www.codeproject.com/useritems/pointertopointer/ptr_to_ptr.jpg)
Título: Re: Puntero A Punteros
Publicado por: Enko en Jueves 29 de Marzo de 2007, 23:46
Por esa casualidad, el tamaño de un puntero y de un puntero a puntero no es el mismo?
Código: Text
  1.  
  2. sizeof(**float) == sizeof(***float)
  3.  
  4.  
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Jueves 29 de Marzo de 2007, 23:49
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
  1.  
  2. sizeof(**float) == sizeof(***float)
  3.  
  4.  


Obvio jeje, no es mas que una direccion de memoria, en x86 4 bytes/32 bits y en x86-64 8bytes/64bits.
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 00:06
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 (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 (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
  1. float_values = (float***)malloc(4 *sizeof(float**));
  2.  

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

Código: Text
  1. (float**)malloc(4 *sizeof(float*));
  2.  

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)
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Viernes 30 de Marzo de 2007, 00:10
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.
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 00:25
Cita de: "AnioN"
otra duda es, con este codigo:

Código: Text
  1.  
  2.  float **float_values;
  3.  float_values = (float**)malloc(4 *sizeof(float*));
  4.  

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. [][][]
Título: Re: Puntero A Punteros
Publicado por: AnioN en Viernes 30 de Marzo de 2007, 01:09
cada vez entiendo menos, a ver, vamos por partes.

Segun esto:
Código: Text
  1.  
  2.  
  3.           float **float_values;
  4.  
  5.  
  6.  
  7.      //allocate memory for rows
  8.  
  9.      float_values = (float**)malloc(4 *sizeof(float*));
  10.  
  11.  

(http://www.codeproject.com/useritems/pointertopointer/ptr_to_ptr.jpg)

Con esto se estarian creando 4 punteros?
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 04:20
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
  1.    float_values = (float**)malloc(4 *sizeof(float*));
  2.  

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
  1. float ***float_values;
  2. float_values = (float***)malloc(4 *sizeof(float**));
  3.  

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:
(http://juank.black-byte.com/Foros/4PunterosAPunteros.png)
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Viernes 30 de Marzo de 2007, 09:26
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
  1.  
  2. float **float_values = (float**)malloc(4 *sizeof(float*));
  3. for (int x= 0; x < 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
  4. *float_values[0] = 3.51;
  5. *float_values[1] = 4.62;
  6. *float_values[2] = 5.73;
  7. *float_values[3] = 6.84;
  8. for (int x= 0; x < 4; x++) { printf("%f\r\n", *float_values[x]); }
  9. for (int x= 0; x < 4; x++) {  free(float_values[x]); }
  10. free(float_values);
  11.  
  12.  

Este grafico si representa mi codigo:
(http://img256.imageshack.us/img256/8640/4ptrtoptrshy6.th.jpg) (http://img256.imageshack.us/my.php?image=4ptrtoptrshy6.jpg)

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.
Título: Re: Puntero A Punteros
Publicado por: AnioN en Viernes 30 de Marzo de 2007, 13:38
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
  1.  
  2. float **float_value s= float_values = (float**)malloc(4 *sizeof(float*));
  3. for (int x= 0; x < 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
  4. *float_values[0] = 3.51;
  5. *float_values[1] = 4.62;
  6. *float_values[2] = 5.73;
  7. *float_values[3] = 6.84;
  8. for (int x= 0; x < 4; x++) { printf("%f\r\n", *float_values[x]); }
  9. for (int x= 0; x < 4; x++) {  free(float_values[x]); }
  10. free(float_values);
  11.  
  12.  

Este grafico si representa mi codigo:
(http://img256.imageshack.us/img256/8640/4ptrtoptrshy6.th.jpg) (http://img256.imageshack.us/my.php?image=4ptrtoptrshy6.jpg)

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
  1. float **float_value s= float_values = (float**)malloc(4 *sizeof(float*));
  2.  
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Viernes 30 de Marzo de 2007, 14:14
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
Código: Text
  1.  
  2. float **float_values = (float**)malloc(4 *sizeof(float*));
  3. ZeroMemory(float_values, 4 *sizeof(float*));
  4. printf("%p\r\n", *float_values);
  5. for (int x= 0; x < 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
  6. printf("%p\r\n", *float_values);
  7.  
  8.  

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.
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 14:53
Cita de: "Eternal Idol"
Hay cuatro direcciones de memoria (punteros float **) reservadas con la primera linea del codigo

Código: Text
  1. float **float_values = (float**)malloc(4 *sizeof(float*));
  2.  

para nada, eso no es lo que existe ahi.

El puntero NO es las 4 posiciones de memoria,
el puntero (float**) esta localizado en una posición memoria X y el contenido en esa posición de memoria es la dirección de la 'primera ' posición de memoria de 4 reservadas.

Es decir un puntero a 4 punteros.

Eso es solo un puntero apuntando a 4 punteros y esta clarisimo.


Hasta ahí es lo que se pidió en un principio...

y ahi va de nuevo, para hacer esto:

Cita de: "AnioN"
y si quiero crear en forma dinámica 4 punteros a punteros?

Se requiere lo que ya he hablado.

http://foros.solocodigo.com/index.php?showtopic=27839&st=21# (http://foros.solocodigo.com/index.php?showtopic=27839&st=21#)
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Viernes 30 de Marzo de 2007, 15:02
Cita de: "JuanK"
para nada, eso no es lo que existe ahi.

El puntero NO es las 4 posiciones de memoria,
el puntero (float**) esta localizado en una posición memoria X y el contenido en esa posición de memoria es la dirección de la 'primera ' posición de memoria de 4 reservadas.
Si yo reservo 16 bytes tengo cuatro direcciones de memoria, aunque no te lo creas y puedo hacer que esas apunten a cuatro nuevas direcciones de memoria que me de malloc y esas direcciones ocupan el tamaño de un float. Por lo tanto son punteros a punteros.
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 15:06
Cita de: "Eternal Idol"
Si yo reservo 16 bytes tengo cuatro direcciones de memoria, aunque no te lo creas y puedo hacer que esas apunten a cuatro nuevas direcciones de memoria que me de malloc y esas direcciones ocupan el tamaño de un float. Por lo tanto son punteros a punteros.
Eso que tu dices es lo siguiente:

"Si reservas 16 bytes tienes 4 posiciones de memoria:" true

"puedo hacer que esas apunten a cuatro nuevas direcciones de memoria que me de malloc": true

pero tu nunca has mostrado que esas 4 apunten a 4 nuevas direcciones de memoria, eso es lo que he mostrado yo.

 "esas direcciones ocupan el tamaño de un float.": lo mismo
Título: Re: Puntero A Punteros
Publicado por: Eternal Idol en Viernes 30 de Marzo de 2007, 15:08
Cita de: "JuanK"
pero tu nunca has mostrado que esas 4 apunten a 4 nuevas direcciones de memoria, eso es lo que he mostrado yo.
Código: Text
  1.  
  2. float **float_values = (float**)malloc(4 *sizeof(float*));
  3. ZeroMemory(float_values, 4 *sizeof(float*));
  4. printf("%p\r\n", *float_values);
  5. for (int x= 0; x < 4; x++) {  float_values[x] = (float*)malloc(sizeof(float)); }
  6. printf("%p\r\n", *float_values);
  7.  
  8.  

¿Te parece que no apuntan a direcciones de memoria nueva? Primero son cero para tu informacion. ¿Si o no? ¿Necesitan usar un triple puntero?
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 15:15
Código: Text
  1.  
  2. float **float_values = (float**)malloc(4 *sizeof(float*));
  3. for (int x= 0; x < 4; x++)
  4. {  
  5.     float_values[x] = (float*)malloc(sizeof(float));
  6. }
  7.  


si, segun tu cada float_values* (o sea cada  float_values

esto

Código: Text
  1. float f = 1.2f;
  2. float *p= &f;
  3.  

seria un puntero a puntero puntero y eso es solo un puntero normal.
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 15:41
Lo que tu citas es un puntero a 4 punteros, no 4 punteros a punteros,

float f;<- variable (que obviamente es una dirección de memoria donde se contiene el float)

float* fp;<- puntero a float, una variable que contiene una direccion de memoria, de ahi que para 'mover el puntero' se pueda hacer fp++ lo cual es aumentar el valor contenido en uno, o sea desplazarce una posicion en la direccion de memoria apuntada
 
float** fpp;-> puntero a puntero float, pero es solo un puntero que puede direccionar 4 posiciones de memoria reservadas.

Un reflexion adicional:

si tengo

Código: Text
  1. char *c;
  2.  
  3. c = (char*)malloc(10);
  4.  

esta claro que c contiene la direccion de memoria del bloque creado con malloc, pero ese bloque no es un 'bloque de punteros' es un 'bloque de caracteres'.

entonces

Código: Text
  1. char** z;
  2. z = (char**)malloc(10 * sizeof(char*));
  3.  

z tiene la dirección de un 'bloque de 10 punteros' , o sea z es un puntero a 'un bloque de 10 punteros'...
estos a su vez pueden apuntar a un 'bloques de N caracteres' cada uno.

así que tenemos solo un puntero apuntado 4punteros más.

En conclusión  z es puntero a puntero... solo 1 no 10.
Título: Re: Puntero A Punteros
Publicado por: AnioN en Viernes 30 de Marzo de 2007, 15:53
Cita de: "JuanK"
Lo que tu citas es un puntero a 4 punteros, no 4 punteros a punteros,

float f;<- variable (que obviamente es una dirección de memoria donde se contiene el float)

float* fp;<- puntero a float, una variable que contiene una direccion de memoria, de ahi que para 'mover el puntero' se pueda hacer fp++ lo cual es aumentar el valor contenido en uno, o sea desplazarce una posicion en la direccion de memoria apuntada
 
float** fpp;-> puntero a puntero float, pero es solo un puntero que puede direccionar 4 posiciones de memoria reservadas.

Un reflexion adicional:

si tengo

Código: Text
  1. char *c;
  2.  
  3. c = (char*)malloc(10);
  4.  

esta claro que c contiene la direccion de memoria del bloque creado con malloc, pero ese bloque no es un 'bloque de punteros' es un 'bloque de caracteres'.

entonces

Código: Text
  1. char** z;
  2. z = (char**)malloc(10 * sizeof(char*));
  3.  

z tiene la dirección de un 'bloque de 10 punteros' , o sea z es un puntero a 'un bloque de 10 punteros'...
estos a su vez pueden apuntar a '10 bloques de caracteres' cada uno.

así que tenemos solo un puntero apuntado 4punteros más.

En conclusión  z es puntero a puntero... solo 1 no 10.
exactamente es lo mismo que yo entiendo, pero no logro entender a lo que se refiere Eternal Idol.
Título: Re: Puntero A Punteros
Publicado por: JuanK en Viernes 30 de Marzo de 2007, 16:02
Según he tradtado de en entender
el punto de vista de Eternal Idol es que dado que

float p

es una variable y toda variable es una direccion de memoria, el hecho de tener

float f= 2.0f;
float *pf= &f;

implica que pf este apuntando a f y que como f es otra dirección de memoria entonces pf es un puntero a un puntero, cosa que no estoy de acuerdo.  <_<
Título: Re: Puntero A Punteros
Publicado por: AnioN en Viernes 30 de Marzo de 2007, 17:17
Cita de: "JuanK"
Según he tradtado de en entender
el punto de vista de Eternal Idol es que dado que

float p

es una variable y toda variable es una direccion de memoria, el hecho de tener

float f= 2.0f;
float *pf= &f;

implica que pf este apuntando a f y que como f es otra dirección de memoria entonces pf es un puntero a un puntero, cosa que no estoy de acuerdo.  <_<
creo que si.