Cuando se declara una variable, el compilador
reserva un espacio de memoria para ella y asocia el nombre de ésta a la
dirección de memoria desde donde comienzan los datos de esa variable. Las
direcciones de memoria se suelen describir como números en hexadecimal. Un
apuntador es una variable cuyo valor es la dirección de memoria de otra
variable. Se dice que un apuntador “apunta” a la variable cuyo valor se
almacena a partir de la dirección de memoria que contiene el apuntador. Por
ejemplo, si un apuntador p almacena la dirección de una variable x, se dice que
“p apunta a x”.
Los apuntadores como cualquier otra variable
deben de ser declarados antes de que puedan ser utilizados. El tipo de un
apuntador lo proporciona implícitamente el tipo de la variable a la que apunta.
Los apuntadores pueden ser declarados para
apuntar a objetos de cualquier clase.
La sintaxis general de declaración es:
<tipo> *
<variable>
Ejemplos de declaraciones:
La variable contPtr es del tipo apuntador a
entero, (int *) y se lee ``contPtr es un apuntador a int'' o ``contPtr apunta a
una variable entera''.
NOTA: Un apuntador a cualquier tipo de variables es una
dirección en memoria, la cual es una dirección entera, pero un apuntador NO es
un entero.
La razón por la cual se asocia un apuntador a un tipo de
dato, es por que se debe conocer en cuantos bytes esta guardado el dato. De tal
forma, que cuando se incrementa un apuntador, se incrementa el apuntador por un
``bloque'' de memoria, en donde el bloque esta en función del tamaño del dato.
Por lo tanto para un apuntador a un char, se agrega un byt a la dirección y
para un apuntador a entero o a flotante se agregan 4 bytes. De esta forma si a
un apuntador a flotante se le suman 2, el apuntador entonces se mueve dos
posiciones float que equivalen a 8 bytes.
Para
declarar un apuntador se especifica el tipo de dato al que apunta, el operador
‘*’, y el nombre del apuntador. La sintaxis es la siguiente:
<tipo de dato apuntado> *<indentificador del
apuntador>
A continuación se muestran varios ejemplos:
Ejemplos
En los ejemplos siguientes se muestran
declaraciones de puntero.
char *message; /* Declares a pointer variable named message */
El puntero message señala a una
variable con el tipo char.
int *pointers[10]; /* Declares an
array of pointers */
La matriz de pointers tiene 10
elementos; cada elemento es un puntero a una variable con el tipo int.
int (*pointer)[10]; /* Declares a pointer to an array of 10 elements */
La variable de puntero señala a una matriz
con 10 elementos. Cada elemento de esta matriz tiene el tipo int.
int const *x; /* Declares a
pointer variable, x,
to a constant value */
El puntero x se puede modificar
para que señale a un valor int diferente, pero el valor al que señala
no puede modificarse.
const
int some_object = 5 ;
int
other_object = 37;
int
*const y = &fixed_object;
int
volatile *const z = &some_object;
int
*const volatile w = &some_object;
La variable y en estas
declaraciones se declara como un puntero de constante a un valor int. El
valor al que señala se puede modificar, pero el propio puntero debe señalar
siempre a la misma ubicación: la dirección de fixed_object. De igual
forma, z es un puntero de constante, pero también se declara para que
señale a un elemento int cuyo valor no lo pueda modificar el
programa.
El especificador
adicional volatile indica que aunque el valor de const int al que
señala z no lo puede modificar el programa, podría modificarlo de
forma legítima un proceso ejecutado simultáneamente con el programa. La
declaración de w especifica que el programa no puede cambiar el valor
al que se señala y que el programa no puede modificar el puntero.
struct list *next, *previous; /* Uses the tag for list */
En este ejemplo se declaran dos variables de
puntero, next y previous, que señalan al tipo de
estructura list. Esta declaración puede aparecer antes que la definición
del tipo de estructura list (vea el ejemplo siguiente), mientras que
la definición de tipo list tiene la misma visibilidad que la
declaración.
struct
list
{
char *token;
int count;
struct list *next;
} line;
La variable line tiene el tipo de
estructura denominado list. El tipo de estructura list tiene
tres miembros: el primer miembro es un puntero a un valor char, el segundo
es un valor int y el tercero es un puntero a otra
estructura list.
struct
id
{
unsigned int id_no;
struct name *pname;
} record;
La variable record tiene el tipo de
estructura id. Observe que pname se declara como un puntero a
otro tipo de estructura denominado name. Esta declaración puede aparecer
antes de que se defina el tipo name.
No hay comentarios:
Publicar un comentario