Como Leer punteros - Tutorial

[KILLERJC]

Otro dia mas de "No tengo idea de C pero estoy haciendo un post" pero que espero que les sirva a todos. El capitulo de hoy se llama:

Como leer punteros en C.. Esos malditos asteriscos,parentesis,etc que hacen que uno pierda la cabeza y no quiera programar mas. Asi que vamos a enseñar a leerlos y de paso aprenderan como crearlos bien y no poniendo parentesis y esperando que funcione como seguro la mayoria hizo en un comienzo.

Como los ejemplos es lo mas comodo para aprender y ver espero que este lleno de los mismos y sirva para todos.

Para seguir este mini-tutorial comenzamos por los ejemplos mas basicos. Mas adelante vamos a necesitar de esta tabla ( si se cae el link busca imagenes en google de "operator precedence C":



El cual nos va a servir para entender el por que de la misma. Esta tabla habla de la precedencia y la asociacion de cada operando.. Mientras mas alta la precedencia significa que va primero, y si hay 2 o mas con la misma precedencia entonces vamos a usar la asociacion para determinar cual va primero, algunos van de izquierda a derecha y otros de derecha a izquierda.

Comenzemos..

Código: C

1. int n;

Pero eso no es un pointer , pero es bueno para comenzar, eso deberia leerse como "declarar n como int". Veamos el primer pointer:

Código: C

1. int *p;

Esto se leeria "p es un pointer que apunta a un int", ¿Y como llegamos a esto?, tomemos como comienzo el nombre del pointer o su identificador ( p ), por la precedencia primero esta el simbolo de puntero *, y luego finalmente el tipo afuera. Que si observan como se "leeria" tiene una correspondencia con el orden.

Veamos un ejemplo mas complejo

Código: C

1. int Array[30][4];
2. int (*p)[4]=Array;
3. int *q[5];

Lo primero es un array 30 x 4, simple como todos. Pero como leo el segundo ? Para esto vamos a desmenuzarlo poco a poco.
Primero observamos donde esta el nombre ( p ), y tenemos algo asi ( x )[ x ], los corchetes y los parentesis tienen el mismo orden de precedencia y se evaluan de izquierda a derecha, es decir que lo primero es lo de dentro del parentesis. Observamos dentro y vemos que "p es un puntero", terminamos de analizar ese parentesis y nos queda evaluar el corchete y finalmente el tipo, quedando de esta forma:

"p es un puntero a un array de 4 elementos de tipo int"

Y uno pensaria que el 3ro es igual pero como se puede observar esta ves NO hay parentesis. y los corchetes [] tiene mayor orden de precedencia que el indicador de puntero * ( no confundir con multilpicacion ). Esto cambia TODO. ya que ahora va el corchete primero quedando en este orden: Nombre, Corchetes, puntero, tipo.

"q es un array de 5 punteros a ints"

Por una parte teniamos un puntero a un array, y ahora tenemos un array de punteros. Veamos un par mas:

Código: C

1. int **p1;  //  p1 es un puntero         a un puntero    a un int
2. int *&p2;  //  p2 es la direccion       a un puntero    a un int
3. int &*p3;  //  ERROR: Un puntero a una referencia es ilegal, no tiene sentido
4. int &&p4;  //  ERROR: Una referencia a una referencia de un int tampoco tiene sentido y es ilegal

Si se preguntan el por que es ilegal esos ultimos 2 piensen lo siguiente:
Un puntero ocupa un espacio en memoria, es decir es una espacio de memoria que tiene una direccion. Si intentamos hacer &*p3, lo que se intenta hacer es un puntero la direccion de un int.. Pero esa direccion del int no ocupa espacio en memoria, es decir no hay una posicion de RAM que tenga ese valor de la direccion, sino que directamente se obtiene del int. Entonces uno no puede apuntar a algo que no existe. Lo mismo ocurre con p4, Es como pedir la direccion donde esta almacenada la direccion del int. Es absurdo ya que como dijimos la direccion no ocupa espacio fisico.

Const / volatile.

Código: C

1. const int n = 3;
2. int const m = 5;

A pesar que cambien de posicion ambos tiene el mismo significado tanto n como m, son de tipo int y constantes. Lo mismo ocurre con esto:

Código: C

1. const int *p;
2. int const *q;

Ambos son exactamente lo mismo, es decir p o q, son punteros a un tipo int constante. Observer que eso no hace constante al puntero si quisieramos que el puntero sea constante seria asi:

Código: C

1. int * const r= &n;

Y si quisieramos completarla, es decir un puntero constante a un int constante

Código: C

1. const int * const p = &q;

Como siemrpe hay mas cosas dejo una tabla de nuevo con distintos casos y que deberia dejar sin dudas respecto cuando es uno u otro, si quieren leerlo comienzen desde el nombre hacia la izquierda ya que no poseen mas operandos

Código: C

1. char ** p1;                    //        puntero a        puntero a        char
2. const char **p2;               //        puntero a        puntero a  const char
3. char * const * p3;             //        puntero a  const puntero a        char
4. const char * const * p4;       //        puntero a  const puntero a  const char
5. char ** const p5;              //  const puntero a        puntero a        char
6. const char ** const p6;        //  const puntero a        puntero a  const char
7. char * const * const p7;       //  const puntero a  const puntero a        char
8. const char * const * const p8; //  const puntero a  const puntero a  const char

Punteros a funciones

Los punteros a funciones son algo simples de ver y casi siempre tienen esta forma:

tipo (x)(argumentos)

Obviamente tal ves no tan simple asi, pero ya vamos a ver unos ejemplos. El ejemplo mas simple seria:

Código: C

1. int (*p)(char);

Nuevamente observamos donde esta el nombre, en nuestro caso es p. Y que esta entre parentesis, en esos 2 parentesis al tener la misma precedencia nos fijamos en la asociacion y vemos que es de izquierda a derecha. Entonces primero tomamos el parentesis de la izquierda, luego el de la derecha y finalmente el int ( recordando que las funciones devuelven valores ). Y vamos creando nuestra definicion:

"p es un puntero a una funcion que toma un argumento char y que devuelve un int"

Otro ejemplo

Código: C

1. char ** (*p)(float,float);

Ocurre lo mismo que el caso anterior, primer parentesis, luego el segundo, luego los punteros y finalmente el char. Y esto se leeria:

"p es un puntero a una funcion que toma como argumento 2 float y que devuelve un puntero a un puntero a un char"

Siempre hay alguien complicado y podemos seguir agregando, este es el ultimo ejemplo:

Código: C

1. void * (*a[5])(char * const, char * const);

Este es mas complejo.. pero empezemos a separarlo.. tenemos nuevamente nuestros 2 parentesis ( misma precedencia y que por su asociacion es de izquierda a derecha) Asi que lo primero es (*a[5]), como los corchetes tiene mas precedencia que el simbolo de puntero quedaria:

"a es un array de 5 punteros"

Luego observamos el segundo parentesis y vemos que "char * const" son 2 punteros constantes a un char. Uniendo y usando luego lo de afuera:

"a es un array de 5 punteros a funciones que tienen como argumento 2 punteros constantes a char y que devuelven un puntero void"

-------------------------

2 ejemplos mas el cual van a separarse para que la gente lo vea un poco mas claro:

Código: C

1. int * (* (*fp1) (int) ) [10];
2.          (*fp1)                 // fp1 es un puntero
3.                 (int)           // a una funcion que toma como argumento un int
4.       (*              )         // y que devuelve un puntero
5.                         [10]    // a un array de 10
6. int *                           // punteros a int

Código: C

1. int *( *( *arr[5])())();
2.            arr[5]               // arr es un array de 5
3.           *                     // punteros
4.                   ()            // a funciones
5.        *(           )           // que devuelven punteros
6.                      ()         // a funciones
7. int *                           // y que devuelven punteros a ints

EDIT:

Otro ejemplo que es muy comun de ver es;

Código: C

1. *ptr++

Con experiencia uno sabe que primero se accede al pointer se realiza lo que tiene que hacerse y luego se incrementa el pointer y no el contenido del mismo.
Ahora si uno se fija en la tabla, observara que el post incremento tiene la mayor precedencia y luego esta el puntero. Lo cual es equivalente a hacer:

Código: C

1. *(ptr++)

Y es el por que se incrementa el puntero y no el contenido del puntero

[fernandogomav]

Ahora esta muchísimo mas claro todo, gracias KILLERJC 

[Miquel_S]

Gracias KILLERJC por molestarte en enseñar, espero que dicho tutorial se alargue.

Saludos!

[KILLERJC]

Gracias KILLERJC por molestarte en enseñar, espero que dicho tutorial se alargue.

¿Que te gustaria ver exactamente?, Ejemplos de uso de punteros a funciones? Callbacks ? (seria  casi lo mismo ) o ejemplos aplicados en punteros?.
La idea era enseñar como leer un puntero pero de ahi uno se puede extender mas.

[Miquel_S]

Gracias KILLERJC por tu respuesta, seguro que surgirán muchas dudas pero debo ir paso a paso estoy cansado de saltar de un lado a otro sin que al final me quede nada claro, y lo digo porque siempre intento entender los códigos que ponéis y normalmente por no decir siempre no me entero de la película, por este motivo he decidido a partir de ahora aprender C lo máximo posible he ir preguntando lo que no entienda y de momento estoy leyendo todo lo que encuentro relacionado con los punteros, arrays, struct, etc..

De nuevo gracias por las molestias que vos estáis tomando tu y el resto en general.

Miquel_S

[KILLERJC]

Vos sabes que sos libre de preguntar, y que seguro la respuesta va a llegar. Asi que cualquier duda que poseas nombrala aca o en otro lado e itentamos contestarla

[jfh900]

Muy buen tutorial. Gracias por el aporte

Un saludo

[Miquel_S]

Vos sabes

TU, que todavia soy joven solo tengo 50 

 
Gracias.

[KILLERJC]

Vos sabes

TU, que todavia soy joven solo tengo 50 

 
Gracias.

Nunca diferencie el Vos y el Tu como para diferenciar en edad, y si es mas respeto y aun viejito normalmente es "Usted". Tal ves constumbre mia al hablar pero que no se mal entienda 

[electroipod]

La teoría es buena hasta cierto punto pero debería de haber ejemplos de como se usa cada declaración, esta teoría ya lo había visto en libros pero igual no ponian ejemplos de su uso, ojala puedas hacer un tutorial con ejemplos se te agradecería bastante.

[KILLERJC]

La teoría es buena hasta cierto punto pero debería de haber ejemplos de como se usa cada declaración, esta teoría ya lo había visto en libros pero igual no ponian ejemplos de su uso, ojala puedas hacer un tutorial con ejemplos se te agradecería bastante.

El tema era leer punteros.. para el que no sabe sobre la precedencia o si ir de izquierda a derecha o derecha a izquierda.
El tema de ejemplos puedo llegar hasta cierto punto, Tienen que ser simples. Por que tal ves algunos ejemplos sean demasiados puntuales, es decir que sentido tiene hacer un ejemplo de un puntero asi:

Código: C

1. int ******ptr;

Si tal ves en una aplicacion lo tendrias que hacer. No se como llegarias a eso, pero en internet hay gente que se ha encontrado con eso y pensado que realmente se trababa de un comentario.

Si se puede dar ejemplos de punteros a funciones, "callback" ( pasar punteros a funciones por el argumento ) , realizar tal ves una maquina de estado con las mismas que es lo mas habitual de ver en todos lados por la simple que es.
Cuando usamos un puntero para leer un volatile como escribirlo. Es lo unico que se me ocurre. Si poseen mas ideas para realizar un ejemplo simple lo hago.
A no ser que realmente quieran entrar en que es un puntero, y como se usa. Que ya es otro topic totalmente aparte. Y al menos este post fue destinado a gente que usa punteros, pero que no sabe bien leerlos, es decir llega hasta un

Código: C

1. char array[10];
2. int *ptr = array;

O pasar un puntero de una estructura a una funcion.
Hago lo que ustedes deseen.

[electroipod]

La teoría es buena hasta cierto punto pero debería de haber ejemplos de como se usa cada declaración, esta teoría ya lo había visto en libros pero igual no ponian ejemplos de su uso, ojala puedas hacer un tutorial con ejemplos se te agradecería bastante.

El tema era leer punteros.. para el que no sabe sobre la precedencia o si ir de izquierda a derecha o derecha a izquierda.
El tema de ejemplos puedo llegar hasta cierto punto, Tienen que ser simples. Por que tal ves algunos ejemplos sean demasiados puntuales, es decir que sentido tiene hacer un ejemplo de un puntero asi:

Código: C

1. int ******ptr;

Si tal ves en una aplicacion lo tendrias que hacer. No se como llegarias a eso, pero en internet hay gente que se ha encontrado con eso y pensado que realmente se trababa de un comentario.

Si se puede dar ejemplos de punteros a funciones, "callback" ( pasar punteros a funciones por el argumento ) , realizar tal ves una maquina de estado con las mismas que es lo mas habitual de ver en todos lados por la simple que es.
Cuando usamos un puntero para leer un volatile como escribirlo. Es lo unico que se me ocurre. Si poseen mas ideas para realizar un ejemplo simple lo hago.
A no ser que realmente quieran entrar en que es un puntero, y como se usa. Que ya es otro topic totalmente aparte. Y al menos este post fue destinado a gente que usa punteros, pero que no sabe bien leerlos, es decir llega hasta un

Código: C

1. char array[10];
2. int *ptr = array;

O pasar un puntero de una estructura a una funcion.
Hago lo que ustedes deseen.

ok, entonces cada declaración que has hecho arriba ponle un ejemplo simple.
me gustaría saber como uso esto y donde lo uso:
int *ptr1[]; /*Array de punteros a int*/
int (*ptr2)[];/*Puntero a un array de elementos int*/
int *(*ptr3)[];/*Puntero a un array de punteros a int*/

[RSC]

buenisimo!!! gracias 

[KILLERJC]

EDIT: Pido perdon por la demora pero hubo un par de tormentas estos dias muy electricas y se me lleno la casa de placas a arreglar de Tambos que se necesitaban con rapidez su reparacion. Y no habia podido dedicarme a hacer los codigos y probarlos

Eletroipod
Como usarlo es una cosa... y lo puedo demostrar.
Donde usarlo eso va a depender de lo que tengas que hacer, en estos momentos no se me ocurre nada pero seguro que en algun momento puede que lo llegues a utilizar o tal ves jamas lo uses.
Pero bueno el objetivo del tutorial como dije era aprender a leerlos, nada mas. Usarlos era otro tema totalmente distinto.

Personalmente me encuentro con algo raro de ver array de punteros a int (ya que normalmente accedemos al int directo), pero si puede ser array de punteros a funciones.

Comencemos por el primero:

Código: C

1. int *ptr1[]; /*Array de punteros a int*/

Es un array de punteros a ints. Lo unico que se me ocurre rapidamente es:
Suponete que tengas que usar 5 valores de 10 enteros. Se puede realizar de varias formas

Código: C

1. const uint8_t ValoresOriginales[10] = {5,10,34,53,123,62,173,51,56,250};
2. static uint8_t Seleccion[5];
3. static uint8_t ValorFinal[5];
4. const uint8_t *ptr[5];
5.  
6.  
7. //Supongamos que quiero sacar los indices 2,7,9,6,1, y ponerlos en ValorFinal[]
8.  
9. // Omito las definiciones de las variables usadas en los for, para no sobrecargar esto.
10. // Con arrays:
11.  
12. Seleccion[0] = 2;
13. Seleccion[1] = 7;
14. Seleccion[2] = 9;
15. Seleccion[3] = 6;
16. Seleccion[4] = 1;
17.  
18. for(i=0;i<5;i++)
19. {
20.         ValorFinal[i] = ValoresOriginales[Seleccion[i]];
21. }
22.  
23. // Con punteros puedo hacer lo mismo..
24.  
25. uint8_t *punteroFinal = ValorFinal;
26. const uint8_t *punteroOriginal = ValoresOriginales;
27. uint8_t *punteroSeleccion = Seleccion;
28.  
29. for(i=0;i<5;i++)
30. {
31.         *punteroFinal = *(punteroOriginal + *punteroSeleccion);
32.         punteroFinal++;
33.         punteroSeleccion++;
34. }
35.  
36. // O sino podriamos cargar los punteros de cada uno.
37.  
38. ptr[0] = ValoresOriginales + 2;         //Igual que  &ValoresOriginales[2]
39. ptr[1] = ValoresOriginales + 7;         //Igual que  &ValoresOriginales[7]
40. ptr[2] = ValoresOriginales + 9;
41. ptr[3] = ValoresOriginales + 6;
42. ptr[4] = ValoresOriginales + 1;
43.  
44. for(i=0;i<5;i++)
45. {
46.         ValorFinal[i] = *ptr[i];
47. }

Probados y funcionan los 3 metodos, si queres simularlos pone un for borrando ValoresFinales[] entre cada "solucion" :

Código: C

1. for(i=0;i<5;++i) { ValorFinal[i]=0; }

Siguiendo con los demas:

Código: C

1. int (*ptr2)[];/*Puntero a un array de elementos int*/

Esto es mas simple, un puntero a un array de int.

Código: C

1. uint8_t ValoresOriginales[2][10] = {{20,21,22,23,24,25,26,27,28,29},{1,2,3,4,5,6,7,8,9,10}};
2. uint8_t (*ptr)[10] = ValoresOriginales;
3.  
4. i = (*ptr)[5];                  // i = 25
5. i = (*(ptr + 1))[5];            // i = 6
6. i = (*ptr)[0];                  // i = 20
7. i = (*(ptr + 1))[0];            // i = 1
8.  
9. // La base del array es un puntero. Asi que puedo tambien representar los [] como sumas a la base :P
10.  
11. i = *((*(ptr)) + 3);            // i = 23
12. i = *((*(ptr + 1)) + 3);        // i = 4

Como mi puntero es "a un array de 10 ints", si hago una operacion matematica sobre este el resultado es que cada 1 que sume al puntero se desplaza el tamaño de 10 ints

Y finalmente, el mas complejo.

Código: C

1. int *(*ptr3)[];/*Puntero a un array de punteros a int*/

Que creo que realmente no se me ocurre NADA, pero voy a mostrar como usarlo de todas formas, tuve cierto problemas con MPLAB que no quiso aceptarme algunos punteros como deberia.

Código: C

1. const uint8_t ValoresOriginales1[10] = {0,1,2,3,4,5,6,7,8,9};
2. const uint8_t ValoresOriginales2[10] = {10,11,12,13,14,15,16,17,18,19};
3. const uint8_t ValoresOriginales3[10] = {20,21,22,23,24,25,26,27,28,29};
4. const uint8_t *ptrVal[3] = {ValoresOriginales1,ValoresOriginales2,ValoresOriginales3};          // Array de 3 punteros a const int
5.  
6. // A pesar que ptrVal es un "array" de 3 punteros a const int, MPLAB me lo toma como "puntero a const uint8_t" es decir no es un "array",
7. // Y por ende al intentar asignarle el valor al ptr levanta un warning diciendo que son "incompatibles",
8. // De todas formas compila, y por si las dudas castee el pointer a este nuevo tipo, asi eliminaba el warning ya que lo que estaba haciendo para mi es correcto.
9.  
10. const uint8_t *(*ptr)[3] = (const uint8_t *(*)[3])ptrVal;
11.  
12. i = (*ptr)[0][5];       // i = 5
13. i = (*ptr)[1][5];       // i = 15
14. i = (*ptr)[2][5];       // i = 25
15.    
16. i = (*(*ptr + 0))[3];       // i = 3
17. i = (*(*ptr + 1))[3];       // i = 13
18. i = (*(*ptr + 2))[3];       // i = 23
19.    
20. i = *((*(*ptr + 0))+8);       // i = 8
21. i = *((*(*ptr + 1))+8);       // i = 18
22. i = *((*(*ptr + 2))+8);       // i = 28

En este ultimo como se vio tuve problemas el cual necesite castear el puntero a "otro tipo", realmente no entiendo por que deberia haber realizado esto, de la definicion:

Código: C

1. const uint8_t *ptrVal[3]

Es un ARRAY de 3 punteros a const uint8_t, pero MPLAB me levanta un warning diciendo que es un "puntero a un puntero a const uint8_t" , lo cual no es cierto ya que tiene 3 elementos. Y no estoy definiendo un puntero sino un array.

Salvo esta excepcion y que realmente no se para que usaria todo esto ahi tenes los ejemplos, lo mas seguro es que nunca lo uses, o sea muy especifico para un programa.
Y tambien que muchos terminarian en typedef para simplificar el codigo del mismo.

EDIT2: Si alguno sabe como solucionar ese warning que me lo diga, realmente pienso que es un error del compilador y no mio. Pero si es mio agradeceria que me lo confirmen.

[Berto]

En principio esto no tiene sentido
int p;
int *p;//todas son puntero por defecto

Pero si me parece ver de lejos que los * y & son un atajo a la hora de crear macros
respecto a un array int mas simple, me gustaria saber si e entendido algo. No lo e probado

int array[10]{0,10,20,33,44,55,66,77,88,99}

int (*p)=array

//si modifico p=3; ¿¿cuando lo lea me dara 33??