• Una variable que apunta a otra variable.

• Un puntero
• Contiene la dirección de otra variable.
• Es una referencia a otra variable.

• Operador &
• Permite obtener la dirección de una variable.
• Válido para cualquier variable.

• Operador *
• Permite acceder al objeto al que el puntero apunta (indirección).
• Sólo es válido para punteros.

int a = 10, b = 20, c[10];

int *p;

p = &a;
b = *p;
*p = 0;
p = &z[0];

int main() {
   int y, *z;
   y = 4;
   z = &y;
   y = *z + 9;   return 0;
}

int main() {
  int foo, *bar, **baz, quux;
    bar = &quux;
  foo = 4;
    baz = &bar;
  **baz = 13;
    bar = &foo;
  **baz = 9;
    return 0;
}

int main() {
  int a, b, *p, *q;
  a =10;
  b =20;
    p = &a;
  q = &b;
  *q = a + b;
    a = a + *q;
  q = p;
  *q = a + b;
  printf("a=%d b=%d *p=%d *q=%d",a,b,*p,*q);
}

char *str_ptr;
char str_array[];
str_pointer++;     // Se valestr_array++;       // No se vale :(
int* int_array = {1, 2, 3};   // No se vale :(

• El nombre de un arreglo
• Es la dirección de la base del arreglo.
• NO es un puntero.
• Durante el ensamblaje, el nombre se reemplaza por la dirección.

int array[5] = {1, 2, 3, 4, 5};
// ptr = array;
int *ptr = &array[0];

array[1];        // *(ptr+1);
array[3];        // *(ptr+3);
array[2] = 5;    // *(ptr+2) = 5;

 x = *p++;   =>  p =  p + 1;   =>  x = *p;

 x = (*p)++;   => *p = *p + 1;   =>  x = *p;

• pointer + integer
• integer + pointer
• pointer + pointer
• pointer – integer
• integer – pointer
• pointer – pointer
• compare pointer to pointer
• compare pointer to integer
• compare pointer to 0
• compare pointer to NULL

• pointer + integer
• integer + pointer
• pointer + pointer
• pointer – integer
• integer – pointer
• pointer – pointer
• compare pointer to pointer
• compare pointer to integer
• compare pointer to 0
• compare pointer to NULL

 int* ptr_array[10];

• ptr_array es un arreglo:
• 10 posiciones
• cada posición es un puntero.

int* p = ptr_array[0];// p es el puntero en la posición 0
int a  = *ptr_array[0];// a es el contenido del puntero en la pos. 0

int a[10][10];int *b[10];

• a es una matriz
• 10 x 10 (100 enteros)
• tamaño constante

• b es un arreglo:
• 10 punteros
• cada puntero puede
• apuntar a otros arreglos de distintos tamaños.
• apuntar a enteros  u otros tipos de datos.
• no apuntar a nada.

• C permite declarar punteros a funciones.

• Dado que un puntero se puede enviar como argumento, entonces podemos enviar funciones como argumentos!

int (*func)();

x = *(p+1)
  => x = *(p+1);

x = *p+1
  => x = (*p) + 1;
x = (*p)++
  => x = *p; => *p = *p + 1;
x = *p++ ? (*p++) ? *(p)++ ? *(p++) ?
  => x = *p ; p =  p + 1;
x = *++p ? 
  => p = p + 1 ;  => x = *p ;

void addOne(int  x){    x =  x + 1;}

int y = 5;
addOne(y);
printf(“y = %d\n”, y);

void addOne(int *p){   *p = *p + 1;}

int y = 5;
addOne(&y);
printf(“y = %d\n”, y);

void incrementPtr(int  *p){   p =  p + 1;}

int a[3] = {50, 60, 70};
int *q   = a;
incrementPtr(q);
printf(“*q = %d\n”, *q);

void incrementPtr(int **h){   *h = *h + 1;}

int a[3] = {50, 60, 70};
int *q   = a;
incrementPtr(&q);
printf(“*q = %d\n”, *q);