Otra introducción a apuntadores

Material de apoyo Programación
Avanzada
Otra introducción a apuntadores

Definición
 Cada vez que se declara una variable C++ el
compilador establece un área de memoria para
almacenar el contenido de una variable.
 El espacio para esa variable se sitúa en una
posición específica de la memoria, conocida
como “dirección de memoria”
 Cuando se referencia o hace uso de la variable,
el compilador de C++ accede automáticamente a
la dirección de memoria asignada a dicha
variable
 Se puede ganar en eficacia en el acceso a esta
dirección de memoria utilizando un puntero o
apuntador.
30/09/20152 Mtl Lourdes Cahuich

 Cada variable que se declara en C++ se tiene
una dirección de memoria asociada a ella.
 Un puntero o apuntador almacena una dirección
de memoria.
 Una analogía es cuando se envía un correo, su
contenido se entrega con base en la dirección a
donde se dirige dicho correo.
 Otra analogía es una llamada telefónica, el
número de teléfono apunta hacia dónde
encontrar a la persona con quien queremos
hablar.

 Un apuntador en C++ también indica dónde
encontrar algo.
 Un puntero C++ es la dirección de una variable.

Reglas básicas
 Un puntero es una variable como cualquier otra
 Un apuntador o puntero contiene una dirección
que apunta a otra posición en memoria
 En esa posición se almacenan los datos a los
que apunta el puntero
 Un apuntador o puntero “apunta” a una dirección
de memoria

75
p
n
El valor de un apuntador es una
dirección.
La dirección depende del estado de
la computadora en el cuál se ejecuta
el programa

Ejemplo
#include <iostream>
using namespace std;
int main(){
int n = 75;
int *p = &n; //contiene la dirección de la variable n
cout << "n = " << n << " ,&n = " << &n << " , p = " << p <<
endl;
cout << "&p = " << &p << endl;
system("pause");
return 0;
}

Análisis del ejemplo
 La variable “p” se denomina “puntero” debido a
que si valor “apunta” a la posición de otra
variable.
 Es un puntero “int” cuando el valor al que apunta
es de tipo “int” como el del ejemplo anterior

Declaración de apuntadores
<tipo_de_dato_apuntador> *<nombre_apuntador>;
ejemplos:
int *ptr1; //apuntador a tipo de dato entero (int)
long *ptr2;
char *ptr3;
float *f;
--Siempre que aparezca un * en la declaración de una
variable, ésta es una variable apuntador--

Inicialización de punteros
 La inicialización de un apuntador proporciona a
ese apuntador la dirección del dato
correspondiente.
 Después de la inicialización se puede utilizar el
puntero para diferenciar los datos direccionados.
(Es como si te dieran una dirección de un
domicilio y además te dieran la llave para entrar a
ver qué hay en dicho domicilio)
 Asignar un valor a la dirección de memoria:
*p = 50;

Inicialización del apuntador
 Cuando ya se ha definido un apuntador, el
asterisco adelante de la variable apuntador
indica “el contenido” de la memoria apuntada por
el apuntador y será del tipo dado.
 Este tipo de inicialización es estática, ya que la
asignación de memoria utilizada para almacenar
el valor es fijo y no puede desaparecer.
 Una vez que la variable se define, el compilador
establece suficiente memoria para almacenar un
valor del tipo de dato dado.

 La memoria permanece reservada para esta
variable y no se puede utilizar para otra cosa
durante la ejecución del programa (no se puede
liberar la memoria reservada para una variable)
 Existe un segundo método para inicializar un
apuntador, mediante la asignación dinámica de
memoria. Este método utiliza operadores new y
delete, y lo veremos más adelante.

Indirección de apuntadores
 Después de definir una variable apuntador, el
siguiente paso es inicializar el puntero y utilizarlo
para direccionar algún dato específico en
memoria.
 El uso de un puntero para obtener el valor al que
apunta, es decir, su dato apuntado, se denomina
“indirección del puntero”
 Para ello se utiliza el operador de indirección *

Indirección (continuación)

Ejemplo de crear, inicializar e
indireccionar un apuntador
#include <iostream>
using namespace std;
char c; //variable caracter
int main(){
char *pc; //apuntador a una variable caracter
pc = &c;
for (c = 'A'; c <= 'Z'; c++)
cout << *pc <<endl;
system("pause");
return 0;
}

 La ejecución de este programa visualiza el
alfabeto.
 La variable puntero pc es un apuntador a una
variable carácter.
 La línea pc = &c; asigna a pc la dirección de la
variable c (&c)
 El bucle for almacena en c las letras del alfabeto
y la sentencia cout << *pc; visualiza el contenido
de la variable aputada por pc.
 c y pc se refieren a la misma posición en
memoria, de modo que el cambio de una variable
debe afectar a la otra.

Algunos códigos de ejemplo
30/09/2015Mtl Lourdes Cahuich21
 Escribe un programa en C++ en donde declares
dos variables flotantes y les asignes valores
diferentes a cada una
 Declara una variable apuntador de tipo flotante.
 Guarda en la variable apuntador la dirección de
la primera variable flotante que declaraste
 Imprime en pantalla el contenido de la dirección
de memoria que tiene guardada la variable
apuntador
 Ahora en la variable apuntador guarda la
dirección de memoria de la segunda variable
flotante que declaraste
 Imprime en pantalla el contenido de la dirección
de memoria que tiene guardada la variable

#include <iostream.h>
int main()
{
float v1 = 756.423;
float v2 = 900.545;
float *p_v;
p_v = &v1;
cout << "El primer valor es" << *p_v << endl;
//se imprime 756.423
p_v = &v2;
cout << "El segundo valor es" << *p_v << endl;
//se imprime 900.545;
return 0;
}

Descubre qué realizan los
siguientes códigos
Escribe los siguientes códigos en tu computadora y
descubre su uso.
Crea un programa y en la función “main” haz uso de la
siguiente función ( el código está en varias diapositivas)

void OperadoresAritmeticos(void){
int x = 10, y = 2, z[3], *p;
p = NULL;
cout << "nvalores iniciales variablesn";
cout << "x = " << x << "n";
cout << "y = " << y << "n";
cout << "p = " << p << "n";
// cout << "*p" << *p << "n";
// cout << "&p" << &p << "n";
cout << "&z[0] = " << &z[0] << " &z[1] = " << &z[1] << " &z[2] = " <<
&z[2] << "n";

p = &z[2];
cout << "nvalores de variables despues de p = &z[2]n";
cout << "x = " << x << "n";
cout << "y = " << y << "n";
cout << "p = " << p << "n";
cout << "*p = " << *p << "n";
cout << "&p = " << &p << "n";
cout << "&z[0] = " << &z[0] << " &z[1] = " << &z[1] << " &z[2] = " << &z[2] <<
"n";

*p = *p + 2;
cout << "nvalores de variables despues de *p = *p + 2;n";
cout << "x = " << x << "n";
cout << "y = " << y << "n";
cout << "p = " << p << "n";
cout << "*p = " << *p << "n";
cout << "&p = " << &p << "n";
cout << "&z[0] = " << &z[0] << " &z[1] = " << &z[1] << " &z[2] = " << &z[2] <<
"n";

p++;
cout << "nvalores de variables despues de p++n";
cout << "x = " << x << "n";
cout << "y = " << y << "n";
cout << "p = " << p << "n";
cout << "*p = " << *p << "n";
cout << "&p = " << &p << "n";
cout << "&z[0] = " << &z[0] << " &z[1] = " << &z[1] << " &z[2] = " << &z[2] << "n";
}

¿Qué es lo que hace el
procedimiento anterior?

Otra introducción a apuntadores

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (14)

Ähnlich wie Otra introducción a apuntadores

Ähnlich wie Otra introducción a apuntadores (20)

Mehr von UVM

Mehr von UVM (16)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Otra introducción a apuntadores