Punteros
Un puntero o un indicador es una referencia a un objeto de un tipo especificado de forma indirecta. Básicamente un puntero contiene la posición de memoria de un tipo de dato.
Los punteros permiten trabajar por referencia, crear y manipular objetos dinámicos de datos como estructuras, listas, pilas, colas y árboles.
Declaración
Los punteros se ha de declarar como punteros mediante la utilización del operador unitario ‘*' (indirección). Para su declaración, al ser una variable se rige por los mismos mecanismos aplicados a la declaración de cualquier variable. Como un puntero representa la indirección de una variable (apunta a la variable), se ha de declarar del tipo de dato de la variable a la que apuntará.
TipoDato *NombreVariable;
Ejemplo de declaración de un puntero de nombre p que apuntará a una variable de tipo int entero:
int n; // Decleración de una variable entera n
int *P; // Declaración de una variable puntero p a un tipo entero
El operador de dirección &
-
Regla:
- p=... Cuando se utiliza el nombre del puntero se accede al dato contenido, al valor de la dirección de memoria de la variable.
- *p=... Cuando se utiliza con el operador ‘*' se accede a la indirección, se trabaja con el contenido de la memoria apuntada.
-
Pasos a seguir para trabajar con punteros y no cometer errores.
- Declarar el puntero de tipo determinado ( int *p; ).
- Iniciar el puntero, hacer que apunte a la variable ( p=&...; ).
- Trabajar con el puntero ( *p=...; ).
Ejemplo de punteros, copiar vectores
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
// Funciones protipo
void copiaVector(int *v1, int *v2, int num);
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[]){
// Variables
int v[]={3, 34, 1, 53, 15, 6}; // Vector 1
int x[6]; // Vector 2
// Visualizar el vector con números aleatorios
for(int n=0; n<6; n++){
cout << x[n] << " ";
}
copiaVector(v, x, 4);
// Visualizar el vector copiando los 4 primeros términos
cout << endl;
for(int n=0; n<6; n++){
cout << x[n] << " ";
}
getch();
return 0;
}
//---------------------------------------------------------------------------
/* función copiar vector de tipo entero
v1-> puntero a vector original
v2-> puntero a vector destino
num -> número de elementos a copiar
*/
void copiaVector(int *v1, int *v2, int num){
for(int n=0; n<num; n++){
*(v2+n)=*(v1+n); // Copiar elementos del vector1 en vector2
}
}
Ejemplo de punteros, orden ascendente de un vector
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
#define DIM 6 // Dimensión del array
// Funciones protipo
void copiaVector(int *v1, int *v2, int num);
void ordenA(int *v, int n);
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[]){
// Variables
int v[]={3, 34, 1, 53, 15, 6}; // Vector 1
int x[DIM]; // Vector 2
// Visualizar el vector con números aleatorios
for(int n=0; n<6; n++){
cout << x[n] << " ";
}
copiaVector(v, x, DIM);
// Visualizar el vector copiando los términos
cout << endl;
for(int n=0; n<DIM; n++){
cout << x[n] << " ";
}
ordenA(x, DIM);
// Visualizar el vector ordenado
cout << endl;
for(int n=0; n<DIM; n++){
cout << x[n] << " ";
}
getch();
return 0;
}
//---------------------------------------------------------------------------
/* función copiar vector de tipo entero
v1-> puntero a vector original
v2-> puntero a vector destino
num -> número de elementos a copiar
*/
void copiaVector(int *v1, int *v2, int num){
for(int n=0; n<num; n++){
*(v2+n)=*(v1+n); // Copiar elementos del vector1 en vector2
}
}
/* función ordenar vector ascendente por el método de burbuja
*v-> puntero al vector a ordenar
n-> número de elementos del vector
*/
void ordenA(int *v, int n){
int j, aux;
int i = 0;
bool ord = false;
// Ordenaciones
while(!ord){
// Comparaciones
ord=true;
for(j=0;j<n-1-i;j++){
if(*(v+j)>*(v+j+1)){
// Intercambiar los elementos
aux=*(v+j);
*(v+j)=*(v+j+1);
*(v+j+1)=aux;
ord = false; // Indicador de vector ordenado
}
}
i++;
}
}