Punteros - 1

PUNTEROS

Un puntero (pointer  apuntador) es una variable que contiene una dirección de

memoria (normalmente de otra variable). Se dice que la variable puntero apunta a la
otra variable.

Figura 1

La variable 'ptr' contiene la dirección 1348, que se corresponde con la de la variable

'var', por lo tanto la variable 'ptr' es un puntero y se dice que 'ptr' apunta a 'var'.

• Los punteros proporcionan los medios por los que las funciones pueden modificar
sus argumentos de llamada.
• El uso de punteros puede mejorar la eficiencia de ciertas rutinas.
• Sirven como soporte de ciertas estructuras de datos complejas.
• Un uso inadecuado de los mismos puede causar fallos muy difíciles de encontrar,
pudiendo provocar incluso el fallo del sistema.

DECLARACIÓN DE VARIABLES PUNTERO

Genérica: tipo * nombre ;

Concreta: short * ptr; // Declara un puntero capaz de direccionar variables
de tipo entero.
double * psimple; // Declara un puntero capaz de direccionar variables
de tipo double.
Las variables puntero deben apuntar siempre al tipo de datos correcto ya que, de lo
contrario, el resultado puede ser catastrófico.

LOS OPERADORES DE PUNTEROS

&  Operador unitario. Devuelve la dirección de memoria de su operando.

*  Operador unitario. Devuelve el valor de la variable localizada en la dirección de
memoria que contiene el puntero ( nombre que sigue al asterisco).

ptr = &var ; // El puntero 'ptr' recibe la dirección de la variable 'var'.

dato = *ptr ; // La variable 'dato' recibe el valor que contiene la variable a la que
apunta 'ptr'.
Si tenemos en cuenta la Figura 1, la variable dato recibirá el valor 25.
 Punteros - 2
#include <stdio.h>

void main( void )

{
int cuenta , q;
int *m; // El puntero m sólo es capaz de direccionar variables de tipo entero.

cuenta = 100;
m = &cuenta; // 'm' recibe la dirección de cuenta.
q = *m; // 'q' recibe el valor de la variable a la que apunta 'm' (en este caso a cuenta).

printf("%i" , q ); // Imprime el valor 100.

printf("%i" , *m ); // Así también imprime el valor 100.
}
 Punteros - 3
#include <stdio.h>

void main( void )

{
float x , y;
int *p; // El puntero 'p' sólo es capaz de direccionar variables de tipo entero.

x = 123.456f ;
p = &x ; // 'p' recibe la dirección de 'x' -> ¡ERROR!, 'x' es de tipo float.
y = *p ; /* 'y' recibe el valor de la variable a la que apunta 'p' (el resultado es erró-
neo, ya que sólo se recogen los dos bytes que es capaz de manejar 'p'). */
printf("%f", y ); // Imprime un valor indeterminado.
printf("%f", *p ); // Así también imprime un valor indeterminado.
}
 Punteros - 4
ASIGNACIONES DE PUNTEROS
Como en el caso de cualquier otra variable, un puntero puede utilizarse a la derecha
de una declaración de asignación para asignar su valor a otro puntero que sea del mismo
tipo.

#include <stdio.h>

void main( void )

{
short a = 7 ;
double b ;
short *p1 , *p2 ;
double *q ;

p1 = &a ;
p2 = p1 ; // ¡ CORRECTO !, son del mismo tipo.
printf ("%p - %i \t %p - %i", p1, *p1, p2,*p2 ) ;
q = &b ;
p2 = q ; // ¡ PROBLEMA !, son de distinto tipo.
}
ARITMÉTICA DE PUNTEROS
Sólo existen dos operaciones que se pueden usar con punteros: la suma y la resta. Tan-
to de punteros con constantes y variables como, en el único caso de la resta, de punteros
entre sí, y ello siempre que sean del mismo tipo.
 Punteros - 5
COMPARACIÓN DE PUNTEROS
Se pueden comparar dos punteros en una expresión relacional:
if(p < q)
printf("p apunta a una dirección menor que q");
Generalmente se utiliza cuando dos o más punteros apuntan a un objeto común, a través del cual se
desplazan.
PASO POR REFERENCIA
Una función puede recibir un puntero, sólo es necesario indicarlo en los parámetros:
void Inicializa(double *ptr);

A la función no se le debe pasar el valor de una variable, sino su dirección.

double escala = 3.0;
Inicializa(escala); // ¡ERROR! intentamos pasar el valor de la
variable escala.
Inicializa(&escala); // ¡CORRECTO! pasamos la dirección de escala.

La función recibe en el puntero *ptr una copia de la dirección de la variable escala (paso por valor),
que se comporta como una variable local (por lo tanto desaparece cuando salimos de la función).
Sin embargo, dado que *ptr contiene la dirección de escala, puede utilizarse para referirse a escala,
con lo que el valor de ésta puede modificarse desde el interior de la función.
void Inicializa (double *ptr)
{
*ptr = 12.568; // Cambia el valor de la variable escala.
}
Es un paso por referencia porque no se pasa el valor de la variable sino su dirección, lo que permite
referirse a la propia variable.

#include <stdio.h>
void Intercambia (int * , int *);
void main(void)
{
int x = 5, y = 10;
printf("En principio: x = %i e y = %i. \n", x, y);
Intercambia (&x , &y) ;
printf ("Después del cambio: x = %i e y = %i. \n", x, y);
}
void Intercambia(int *u , int *v) // Aunque no lo parezca, esta función
{ // devuelve dos valores.
int auxiliar ;
auxiliar = *u ;
*u = *v ;
*v = auxiliar ;
}
// Si el programa anterior lo escribiésemos sin * y sin & no funcionaría.