Unidad 6 Punteros

6.1 Declaración e inicialización

6.2 Operadores de apuntador
6.3 Uso de apuntadores
6.4 Llamadas por valor y referencia
 Parámetros

• Son valores que las funciones requieren en casos específicos para realizar una tarea
determinada y se identifican como variables.
• Comúnmente se identifican dos tipos de parámetros:
• Parámetros formales:
• Son aquellos que se especifican en el prototipo y definición de la función, solo es
necesario especificar el tipo de dato (tip_dat) y el nombre o identificador del parámetro
(par).
• Parámetros actuales:
• Son aquellos que se especifican en la llamada o invocación a una función, siendo solo
necesario especificar el nombre del parámetro o su valor directamente.
 Paso de parámetros.

• En las funciones definidas por el programador se presenta una modalidad

donde es necesario enviar valores a una función para que esta realice una
tarea determinada; existen dos formas de enviar valores a una función, estas
son:
• 1) Paso de parámetros por valor.
• 2) Paso de parámetros por referencia.
 1) Pase por valor.

• En este caso, cuando se envían valores a una función y estos no son

alterados en cuanto a su contenido, se dice que se presenta el paso de
parámetros por valor.
• Ejemplo
• Definir una función que dado dos valores enteros retorne o la suma de los
dos enteros.
 2) Pase Por Referencia.

• Significa que lo transferido no son los valores, sino las direcciones de las
variables que contienen esos valores, con lo cual los parámetros actuales
pueden verse modificados. (Sierra, 2007).
• Cuando se llama a una función, los argumentos especificados se pasan por
valor, excepto los arreglos que se pasan por referencia, ya que el nombre del
arreglo es un puntero a dicho arreglo.
Para pasar una variable por referencia, podemos utilizar
una de las dos formas siguientes: (Sierra, 2007).

• Pasar la dirección del parámetro actual a su correspondiente parámetro

formal, el cual tiene que ser puntero.
• Declarar el parámetro formal correspondiente al parámetro actual que se
quiere pasar por referencia, como una referencia. Para ello anteponer el
operador & al nombre del parámetro formal.
 Definición Punteros.

• Toda variable que es declarada en un programa ocupa un espacio en la

memoria principal de la computadora, dicho espacio es identificado por
medio de una dirección, en el programa, ese espacio es identificado por un
nombre de variable antecediendo a este su tipo de dato.(Sierra,2007)
• Un puntero es una variable a la cual se le puede asignar una dirección de
memoria, lo que facilitaría la tarea al compilador, ya que el puntero
contendría la dirección y por lo tanto la referencia directa hacia un valor
determinado.
 ¿Qué es un Puntero?

• Un puntero apunta hacia un valor específico de cierto tipo de dato, lo que significa
que la variable estaría apuntando hacia un tipo de dato en específico.

• Los Punteros o Apuntadores, son variables que contienen la dirección de otra

variable.

• De manera simple, un puntero es una dirección. Al contrario que una variable

normal, un puntero es una variable almacenada en alguna parte del espacio del
programa.
 Dirección de memoria

Cuando una variable se declara se asocian tres atributos: su nombre, su tipo y su dirección de memoria en
hexadecimal

int n=40;

0x22fe4c
cout<<n; // imprimirá 40
n 40 cout<<&n; // imprimirá la posición de memoria de n 0x22fe4c

int
https://www.youtube.com/watch?v=YqoV6UMQEcE
Direcciones de memoria 100 101 102 103 104
40 Ejemplo
int n=40;
n

Direcciones de memoria 100 101 102 103 104

Ejemplo puntero
? 40 int *puntero_n;

puntero_n n

Direcciones de memoria 100 101 102 103 104

puntero_n =&n;
104 40

puntero_n n
 La Dirección de memoria
Por ejemplo la siguiente definición de datos y
pensando que inician en la dirección de memoria
200

Todo dato tiene una dirección de memoria.

dirección de
memoria
Todos los datos se almacenan a partir de una dirección de
memoria y utilizando tantos bytes como sea necesario. 200 Variable 1 Tipo entero 4 bytes
201
202
203
204 Variable 2 Tipo char 1 byte
205 Variable 3 Tipo float 4 bytes
206
207
208

http://www.it.uc3m.es/abel/as/DSP/M2/Pointers_es.html#all_data_has_an_address
 La indirección de memoria

• Supongamos que las direcciones de memoria se representan internamente

con 32 bits (4 bytes). Entonces, podemos almacenar la dirección de Variable
1 (el número 200) en otro lugar en memoria que ocupará 4 bytes por ser una
dirección de memoria.
• La siguiente figura muestra esta situación con la dirección de memoria
almacenada en la posición 300.
200 Variable 1 Tipo entero 4 bytes En C se obtiene la dirección de memoria de cualquier variable
201 mediante el operando &(ampersand) seguido del nombre de la
202
203
variable. En la figura anterior, la expresión &Variable 1 devuelve el
204Variable 2 Tipo char 1 byte valor 200.
205Variable 3 Tipo float 4 bytes El valor que devuelve el operador & depende de la posición de
206
207 memoria de su operando, y por tanto, no está bajo el control del
208 programador. A la dirección de memoria almacenada como dato
en la posición 300 se le denomina “puntero” pues su valor
“apunta” a donde se encuentra la Variable 1. Otra forma de
enunciarlo: en la posición 300 hay un puntero a Variable 1.
300 2004 bytes &Variable 1
 ¿Cómo implementar variable puntero?

• Para utilizar una variable puntero, esta primero debe ser declarada, utilizando el siguiente
formato:
• tip_dat *nom_var; // se le agrega un * al nombre de la variable

• Operadores

• * : acceso al contenido ( otro uso del *, ya que también nos sirve para declarar la variable
tipo puntero)

• & : Obtención de la dirección

 Operadores de punteros.

• Una vez declarada una variable tipo puntero, a esta se le puede asignar una
dirección de memoria por medio de un operador denominado "operador de
dirección (&)", una vez asignada la dirección a una variable puntero,
enseguida se podría accesar y visualizar el valor que está contenido en la
dirección que le fue asignada al puntero, utilizando para esto un "operador
de indirección (*) .
Ejemplos
• //Puntero ejemplo 1
• #include <iostream>
• #include <conio.h>
• int n; //variable tipo entero ocupa 4 bytes
• using namespace std;
• int main(){
• cout<<“Valor de n “<<n<<endl ;
• cin>>n;
• cout<<"\n\n\nValor que capturaste en n "<<n;
• cout<<"\n\nDireccion de n "<<&n <<endl; //& es el operador de dirección
• getch();
• }
• //Puntero ejemplo 2 Crear una variable tipo apuntador
• #include <iostream>
• #include <cstdlib>
• #include <conio.h>
• float p; //variable tipo entero ocupa 4 bytes
• float *apuntador=&p; // Crea un apuntador a una dirección (posición) de memoria de la variable p //
• using namespace std;
• int main(){
• cout<<"Da un numero para p ";
• cin>>*apuntador; //p
• cout<<"\n\n\nValor que capturaste en p "<<p;
• cout<<"\n\nDireccion de p "<<&p <<endl;
• cout<<“Valor vatiable *apuntador "<<*apuntador<<endl;
• getch();
• }
 Intercambia valores de a y b
• Si a=10 y b=20; entonces al intercambiar los valores de a y b , a será = 20 y
b=10
#include <iostream>
using namespace std;
void intercambia(int x, int y){ Función intercambia
int z; z toma el valor de a que es 10
z=x; x toma el valor de b que es 20
x=y; y tomará el valor de z que es 10
y=z; z=10
}
x=20
int main(){
int a=10,b=20; y=10
cout<<"Valor de a "<<a<<endl; Cuando regresa la función imprimirá el valor de
cout<<"Valor de b "<<b<<endl; a ya intercambiada que es 20 y
intercambia(a,b); b sería 10.
cout<<"Valor de a al intercambiarla "<<a<<endl; Compilarlo y vea si hace el intercambio
cout<<"Valor de b al intercambiarla "<<b<<endl;
}
 Punteros reglas de uso
• El símbolo * se usa para DEFINIR un tipo puntero
• El símbolo & se usa para indicar la dirección de una variable
• El símbolo * se usa para ACCEDER al valor del puntero
• El símbolo & se usa en la invocación de funciones, de forma que se pone delante de los parámetros de
Entrada/salida
• Cuando un parámetro es de Entrada /salida en el prototipo y cabecera se indica con un se indica con un tipo
puntero, esto es, poniendo un * delante del nombre
• En el cuerpo de la función los argumentos que son funciones se USAN con un * delante
• Los & solo se usan en el programa principal
• Los * solo se usan en las funciones.