Apuntadores.

Los apuntadores son variables cuyos valores son direcciones de memoria. Por lo general, una
variable contiene directamente un valor específico. Por otro lado, un apuntador contiene la
dirección de una variable que contiene un valor específico.
Asumamos que se declara a variable int n y se almacena el número 3 en ella. La variable debe de
ocupar un espacio en la memoria del ordenador, llamémoslo 0xb4fd44

0xb4fd44

n
3

La variable prtn tipo apuntador “apunta” a la variable n

0xb4fd44

ptrn n
3

Declaración
La declaración de una variable tipo apuntador, se hace de una manera similar a las variables vistas
a lo largo del curso, con la diferencia de un * que debe preceder su nombre, es decir:

int *ptrn;

ptrn

Esta es la declaración de la variable ptrn de tipo apuntador a una variable tipo int.

Asignación
La asignación de una variable tipo apuntador se debe hacer estrictamente a una dirección en
memoria.
Debido a que se desea asignarle la dirección de la variable n al apuntador ptrn se debe de hacer:

ptrn=&n;

Donde el operador & nos ayuda a obtener la dirección de n.

int main() {
int *ptrn, n;
n=3;
ptrn=&n;
 return 0;
}

Cuya representación grafica es:

0xb4fd44

ptrn n
3

Como & es un operador que ayuda a obtener la dirección o referencia de una variable, lo
llamaremos como “operador de referenciación”.

De esta misma forma ¿Cómo se obtiene el dato de la variable n por medio del apuntador ptrn?, se
necesita el operador inverso de &, el cual se representa con *.
Llamaremos “operador de desreferenciación” a *.

Cabe decir que el apuntador ptrn es una variable que también está almacenada en algún espacio
en memoria, supongamos que en 0xb4fd48, es decir:

0xb4fd48 0xb4fd44

ptrn n
3

Ejemplo 1:

int main() {
int *ptrn, n;
n=3;
ptrn=&n;
cout<<n<<endl;
cout<<ptrn<<endl;
cout<<&n<<endl;
cout<<*ptrn<<endl;
cout<<&ptrn<<endl;
return 0;
}
0xb4fd48 0xb4fd44

ptrn n
3

cout<<n<<endl;
Imprime lo que está almacenado en la variable n, es decir, 3.

cout<<ptrn<<endl;
Imprime lo que está almacenado en la variable ptrn, es decir, la dirección de n, 0xb4fd44.

cout<<&n<<endl;
Imprime la dirección o referencia de n, es decir, 0xb4fd44.

cout<<*ptrn<<endl;
Imprime la “desreferenciación” de ptrn, es decir, lo que está almacenado en la variable n, 3.

cout<<&ptrn<<endl;
Imprime la “referenciación” de ptrn, es decir, la dirección de ptrn, 0xb4fd48.
Observe que esto es la “referencia de la referencia”.
Ejemplo 2:
Realice la prueba de escritorio del siguiente programa:

void cubo_por_valor(int n){

n= n*n*n;
}
void cubo_por_referencia(int *ptrn){
*ptrn=*ptrn * *ptrn * *ptrn;
}
int main() {
int n=2;
cout<<n<<endl;
cubo_por_valor(n);
cout<<n<<endl;
cubo_por_referencia(&n);
cout<<n<<endl;
return 0;
}

Desarrollo
Paso 1:

void cubo_por_valor(int n){

n= n*n*n;
}
void cubo_por_referencia(int *ptrn){
*ptrn=*ptrn * *ptrn * *ptrn;
}
int main() {
int n=2;
cout<<n<<endl;
cubo_por_valor(n);
cout<<n<<endl;
cubo_por_referencia(&n);
cout<<n<<endl;
return 0;
}

Comenzando por el programa principal, se declara y se inicializa la variable n con el dato 2, acto
seguido, se imprime la variable n.

n
2
Paso 2:

void cubo_por_valor(int n){

n= n*n*n;
}
void cubo_por_referencia(int *ptrn){
*ptrn=*ptrn * *ptrn * *ptrn;
}
int main() {
int n=2;
cout<<n<<endl;
cubo_por_valor(n);
cout<<n<<endl;
cubo_por_referencia(&n);
cout<<n<<endl;
return 0;
}

La siguiente línea obliga a hacer la prueba de escritorio de la función secundaria

void cubo_por_valor(int n)

void cubo_por_valor(int n) n
2
8

Observe que la variable n que se modifica de 2 a 8, es la variable del programa secundario. La

variable n del programa principal se mantiene con su almacenamiento.

Paso 3:
void cubo_por_valor(int n){
 n= n*n*n;
}
void cubo_por_referencia(int *ptrn){
*ptrn=*ptrn * *ptrn * *ptrn;
}
int main() {
int n=2;
cout<<n<<endl;
cubo_por_valor(n);
cout<<n<<endl;
cubo_por_referencia(&n);
cout<<n<<endl;
return 0;
}

Se imprime el almacenamiento de la variable n del programa principal

Paso 4:

void cubo_por_valor(int n){

n= n*n*n;
}
void cubo_por_referencia(int *ptrn){
*ptrn=*ptrn * *ptrn * *ptrn;
}
int main() {
int n=2;
cout<<n<<endl;
cubo_por_valor(n);
cout<<n<<endl;
cubo_por_referencia(&n);
 cout<<n<<endl;
return 0;
}

La siguiente línea obliga a hacer la prueba de escritorio de la función cubo_por_referencia(&n)

Observemos que el argumento de void cubo_por_referencia es &n pues el prototipo de la función
void cubo_por_referencia(int *ptrn)
Se muestra int *ptrn, que es la declaración de un apuntador llamado ptrn, es decir, en el llamado
de la función en el progama principal debe de ser con una dirección como argumento
cubo_por_referencia(&n)

cubo_por_referencia(int *ptrn) ptrn n

2
8

Al ser ptrn un apuntador que apunta a n del programa principal, entonces *ptrn=2, de modo que
*ptrn=*ptrn * *ptrn * *ptrn=2*2*2=8→ n=8

La variable n es del programa principal, es decir que esta función modifica la variable del programa
principal, lo que no hacia la función anterior.

Paso 5:

void cubo_por_valor(int n){

n= n*n*n;
}
void cubo_por_referencia(int *ptrn){
*ptrn=*ptrn * *ptrn * *ptrn;
}
int main() {
int n=2;
cout<<n<<endl;
cubo_por_valor(n);
cout<<n<<endl;
cubo_por_referencia(&n);
cout<<n<<endl;
return 0;
}