Está en la página 1de 13

Punteros(Apuntadores)

• El tipo de dato del apuntador debe coincidir con el de la variable cuya posición en
memoria apuntan.
• Siempre que queremos usar el apuntador debemos anteponer el asterisco (*) para
indicar que usaremos el valor en la posición de memoria apuntada.
• De no usar el asterisco estaremos haciendo uso de la dirección de memoria más
no del valor almacenado en ésta.
• Después de usar un puntero, especialmente si trabajamos con arreglos o matrices,
es MUY recomendable liberar la memoria utilizada con la función delete
• Un puntero o apuntador puede ser de cualquier tipo de dato
• ampersand (&)un operador de C++ y es comúnmente utilizado para los punteros.
Este operador nos permite obtener la dirección de memoria de una variable
cualquiera y es justo esto (la dirección en memoria) lo que utilizan los punteros
para referenciar valores.
• un apuntador es únicamente una dirección de memoria (un número) y
el asterisco es el que hace obtener el valor referenciado por dicha dirección.
Ejemplos
char *apuntador = NULL; //Declaramos un puntero
//Es recomendable inicializar un puntero en null, para detectar errores fácilmente
char letra //Declaramos una variable
puntador = &letra; //Asignamos al apuntador la dirección de memoria de la
variable
*apuntador = ‘C’; //Modificamos la variable a través del apuntador
cout << letra; //En pantalla se escribe C
#include <iostream>

using std::cout;
using std::endl;

int main()
{
int a; // a es un entero
int *ptrA; // ptrA es un apuntador a un entero
a = 7;
ptrA = &a; // a ptrA se le asigna la dirección de a
cout << "La dirección de a es " << &a
<< "\nEl valor de ptrA es " << ptrA;
cout << "\n\nEl valor de a es " << a
<< "\nEl valor de *ptrA es " << *ptrA;

cout << "\n\nMuestra de que * y & son inverso "


<< "uno de otro.\n&*ptrA = " << &*ptrA
<< "\n*&ptrA = " << *&ptrA << endl;

return 0; // indica terminación exitosa

} // fin de main
#include <iostream>
using std::cout;
using std::endl;
int cuboPorValor( int ); // prototipo
int main()
{
int numero = 4;

cout << "El valor original de numero es " << numero;

// pasa numero por valor a cuboPorValor


numero = cuboPorValor( numero );

cout << "\nEl nuevo valor del numero es " << numero << endl;

return 0; // indica terminación exitosa


} // fin de main
// calcula y devuelve el cubo de un argumento entero
int cuboPorValor( int n )
{ return n * n * n; // eleva al cubo la variable n y devuelve el resultado
} // fin de la función cuboPorValor
// Convierte letras minúsculas en letras mayúsculas
// mediante el uso de un apuntador no constante a un dato no constante
#include <iostream>
using std::cout;
using std::endl;
#include <cctype> // prototipos para islower y toupper
void convierteAMayuscula( char * );
int main()
{
char frase[] = "Clase mm314 I 2017 ";
cout << "La frase antes de la conversion es: " << frase;
convierteAMayuscula( frase );
cout << "\nLa frase despues de la conversion: "
<< frase << endl;
return 0; // indica terminación exitosa
} // fin de main
// convierte una cadena a letras mayúsculas
void convierteAMayuscula( char *ptrS )
{ while ( *ptrS != '\0' ) { // el caracter actual no es '\0'
if ( islower( *ptrS ) ) // si el caracter es minúscula,
*ptrS = toupper( *ptrS ); // lo convierte a mayúscula
++ptrS; // mueve ptrS a la siguiente cadena de caracteres
} // fin de while
} // fin de la función convierteAMayuscula
Uso de const con apuntadores
• El calificador const informa al compilador que
el valor de la variable no deberá ser
modificado .
• El siguiente programa usa un apuntador no
constante a un dato constante
• const char * ptrs se lee de de derecha a
izquierda ,indica que ptrs es un apuntador de
una cadena de caracteres que es constante .
int main()
{
char frase[] = "El examen #3 es el 26 de abril";

cout << "La cadena es:\n";


imprimeCaracteres( frase );
cout << endl;

return 0; // indica terminación exitosa

} // fin de main

// ptrS no puede modificar el carácter al cual apunta,


// es decir, ptrS es un apuntador "de sólo lectura"
void imprimeCaracteres( const char *ptrS )
{
for ( ; *ptrS != '\0'; ptrS++ ) // sin inicializar
cout << *ptrS;

} // fin de la función imprimeCaracteres


/ Fig. 5.12: fig05_12.cpp
// Intento de modificar datos a través de un
// apuntador no constante a un dato constante.

void f( const int * ); // prototipo

int main()
{
int y;

f( &y ); // f intenta una modificación ilegal

return 0; // indica terminación exitosa

} // fin de main

// ptrX no puede modificar el valor de la variable


// a la cual apunta
void f( const int *ptrX )
{
*ptrX = 100; // error: no se puede modificar un objeto
const

} // fin de la función f