Sie sind auf Seite 1von 6

Apuntadores

Apuntadores e Indireccin

Operaciones Bsicas

o Declaracin e Inicializacin

o Dereferenciar (Dereference)

o Aritmtica del Apuntador

Apuntadores e Indireccin

Un apuntador es una variable que almacena la direccin de la memoria de otra variable. Hemos
visto ya en C++ que los tipos de datos dictan el rango y tipo de valores que una variable puede
almacenar. Las variables de los tipos de datos que hemos examinado hasta ahora almacenan
valores como por ejemplo enteros, nmeros de punto flotante y cadenas de caracteres (strings).
La variable apuntador es nica ya que salva la direccin de la memoria de otra variable. La
direccin de memoria es la localizacin especfica en la memoria principal donde existe una
variable durante la ejecucin de un programa.

Los programadores usan apuntadores para acceder y manipular indirectamente otras variables.
Este acceso y manipulacin se considera "indirecta" puesto que se logra usando un apuntador en
vez de la variable real que est siendo modificada. La "indireccin" permite la creacin de las
estructuras de datos complejas y algoritmos poderosos. Por ejemplo, sin apuntadores e
indireccin no sera posible crear una estructura de datos de la lista encadenada.

Operaciones Bsicas

Declaracin e Inicializacin

La declaracin de una variable apuntador requiere el uso de cierta sintaxis desconocida. Una
declaracin del apuntador debe prefijar su nombre de variable con un asterisco (*). Esto significa
para el compilador que la variable declarada es un apuntador. El listado 1 demuestra el
declaracin de algunas variables indicadoras.

1: int *int_ptr;
2:
3: float *float_ptr;

char *char_ptr;

Listado 1 Declaracin del Apuntador

Aunque los apuntadores solamente almacenan direcciones de la memoria, la declaracin de una


variable apuntador debe especificar un tipo de datos especfico cuya direccin de memoria pueda
almacenar el apuntador. Esto es porque las variables de diferentes tipos de datos pueden no
utilizar necesariamente la misma cantidad de almacenaje en memoria. Para permitir el acceso y la
manipulacin indirecta de una variable usando un apuntador, el compilador debe saber el tamao
exacto de la variable. El listado 1 declara tres apuntadores. Ellos son declarados como un
apuntador de tipo int, un apuntador de tipo float y un apuntador de tipo char, respectivamente.

La inicializacin del apuntador tambin requiere algo de sintaxis nueva. No podemos simplemente
inicializar un apuntador a una variable no-apuntador porque los apuntadores almacenan las
direcciones de memoria y valores no regulares. En su lugar, debemos obtener la direccin de
memoria de la variable. El operador address-of (&) regresa la direccin de la memoria de donde
est almacenada la variable. El listado 2 declara una variable entera y fija 100 como su valor inicial.
Luego declara un apuntador del tipo int, inicializado con la direccin de la variable i. En el contexto
de este ejemplo, podemos decir que ptr "apunta" a i.

1: int i = 100;
2:
int *ptr = &i;

Listado 2 Inicializacin del Apuntador

Dereferenciar (Dereference)

El acceso indirecto y la manipulacin de variables usando apuntadores se logra usando el operador


dereference. Un programador aplica el operador dereference (*) para acceder o modificar el valor
de la variable sealada por un apuntador. El Listado 3 demuestra el acceso indirecto y la
modificacin de una variable usando un apuntador.

1: int i = 100;
2:
3: int *ptr = &i;
4:
5:
6: cout << *ptr << endl; // outputs 100

*ptr = 200; // Sets i = 200

cout << i << endl; // outputs 200

Listado 3 Dereferenciacin de apuntadores

Los programadores pueden invocar funciones miembro de un objeto a travs de un apuntador. El


operador de la flecha (->) primero dereferencia el apuntador y en seguida invoca la funcin
miembro nombrada.
1: #include <iostream>
2:
3: #include <cstdlib>
4:
5:
6: using namespace std;
7:
8:
9: class Thing {
10:
11: public:
12:
int number;
13:
14: Thing() : number(0) {}
15:
16:
17:
void method1() {
18:
19: cout << "Method 1" << endl;
20:
21: }
22:
23:
24: void method2() {
25:
26: cout << "Method 2" << endl;
27:
}
28:
29: };
30:
31:
32: int main(int argc, char* argv[]) {
33:
34:
35:
// Direct access
36:
37: Thing thing;

cout << thing.number << endl;

thing.method1();
thing.method2();

// Equivalent indirect access

Thing *ptr = &thing;

cout << ptr->number << endl;

ptr->method1();

ptr->method2();

return EXIT_SUCCESS;

Listado 4 El operador arrow

Solamente podemos dereferenciar de forma segura los apuntadores que sealan hacia direcciones
vlidas de memoria. Dereferenciar apuntadores que no se han inicializado a direcciones de
memoria vlidas causan un error de ejecucin. Una tcnica utilizada para evitar este problema es
la inicializacin de variables apuntador al puntero nulo. El puntero nulo representa un lugar en la
memoria que no puede ser dereferenciado. La inicializacin de punteros al puntero nulo, evita que
una dereferenciacin accidental pueda causar un error de ejecucin. El apuntador nulo es
referenciado usando la macro NULL previamente definida.

1: int *ptr = NULL; // Initialize to null pointer


2:
3:
4: // ... Some other code ...
5:
6:

int i = 100;

ptr = &i; // Now set our pointer


Listado 5 El apuntador null

Los programadores tambin usan apuntadores nulos como valores para indicar el fin de alguna
estructura o secuencia. Ms adelante examinaremos el uso del apuntador null.

Aritmtica del Apuntador

La aritmtica del apuntador es el uso de sumas y restas para cambiar la posicin de memoria que
un apuntador almacena. Estas operaciones son concernientes a la posicin de la memoria
actualmente almacenada en un apuntador. Restar el valor 3 de un apuntador, por ejemplo, mueve
la posicin tres lugares antes del apuntador. El incremento de un apuntador causa que ste
"apunte" a la siguiente posicin de memoria.

La aritmtica del apuntador automticamente toma en cuenta el tamao del tipo de dato
implicado. La adicin del valor 3 a un apuntador de tipo entero, en realidad agrega un 3
multiplicado por el tamao del entero a la posicin actualmente almacenada en el apuntador. Un
tamao comn de int es de cuatro bytes. En este caso, agregar el valor 3 a un apuntador entero,
agrega 12 (3*4) a la posicin de memoria del apuntador. Conocer el nmero real de bytes que la
aritmtica del apuntador suma o resta no es en realidad til para nosotros. Lo que es importante
es entender que C++ realiza esta multiplicacin de manera automtica. Debemos ver la aritmtica
del apuntador como una forma de acceder diferentes posiciones en una estructura de datos (por
lo general un arreglo). El Listado 6, muestra una demostracin de la aritmtica del apuntador.

1: int array[] = {10, 20, 30, 40, 50};


2:
3: int *ptr = &array[0];
4:
5:
6: cout << *ptr << endl; // outputs 10
7:
8:
9: ptr++;
10:
11: cout << *ptr << endl; // outputs 20
12:

ptr--;

cout << *ptr << endl; // outputs 10

cout << *(ptr + 4) << endl; // outputs 50


Listado 6 Aritmtica bsica de los apuntadores

La aritmtica del apuntador tiene muchos usos importantes en la programacin en C++. Un uso es
el recorrido de arreglos (traversal of arrays).

1: int data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};


2:
3: int *ptr = &data[10]; // points to last element in array
4:
5:
6: do {
7:
cout << *ptr << endl;
8:
}

while (ptr-- != &data[0]);

Listado 7 Recorrido de arreglos

Das könnte Ihnen auch gefallen