Sunday, August 29, 2010

Apuntadores en C++

Fuente:
Enciclopedia del Lenguaje C++ 2 ed.
Francisco Javier CEBALLOS (Author)
Alfaomega Grupo Editor (MX) (Editor)

Un puntero es una variable que contiene la dirección de memoria de un dato o de otra variable que contiene al dato. Quiere esto decir que el puntero apunta al espacio físico donde está el dato o la variable.

Un puntero puede apuntar a un objeto de cualquier tipo, como por ejemplo, a una estructura o una función.

Los punteros se pueden utilizar para referenciar y manipular estructuras de datos, para referencias bloques de memoria asignados dinámicamente y para proveer el paso de argumentos por referencia en las llamadas a funciones.

CREACION DE PUNTEROS

Un puntero es una variable que guarda la dirección de memoria de otro objeto. Para declarar una variable que sea un puntero, la sintaxis es la siguiente:
tipo *var-puntero;

En la declaración se observa que el nombre de la variable puntero , var-puntero
*                   puntero a
var-puntero  Es el nombre de la variable puntero
tipo              Especifica el tipo del objeto apuntado, puede ser cualquier tipo primitivo o derivado

Por ejemplo, si una variable pint contiene la dirección de otra variable a, entonces se dice que pint apunta a a. Esto mismo expresado en código C++ es así:
int  a = 0;     // ‘a’ es una variable entera
int *pint;     // pint es un puntero a un entero
pint = &a;     // pint igual a la dirección de a; entonces,
// pint apunta al entero “a”
La definición         int *pint = &a;
es equivalente a:     int *pint;
pint = &a;

En conclusión *pint es un entero que está localizado en la dirección de memoria almacenada en pint. El espacio de memoria requerido para un puntero es el número de bytes necesarios para especificar una dirección máquina, que normalmente son 4 bytes. 

Un puntero iniciado correctamente siempre apunta a un objeto de un tipo particular. Un puntero no iniciado no sabe a dónde apunta. 

&  Devuelve como resultado la dirección de su operando
*           Este operando unitario interpreta su operando como una dirección y nos da como resultado su contenido.

#include
Using namespace std;
Int main()
{
// Las dos líneas siguientes declaran la variable entera a,
// los punteros p y q a enteros y la variable real b.
int  a = 10, *p. *q;
doublé b = 0.0;
q = &a; // asigna la dirección de a, a la variable q.
    // q apunta a la variable entera a
b = *q; // asigna a b el valor de la variable a
*p = 20; // error: asignación no válida
// ¿A dónde apunta p?
cout <<”Enla dirección ” << q  << “” << b << endl;
cout <<”Enla dirección ” << p  << “” << *p << endl;
}
En la dirección 0x22ff6c está el dato 10
En la dirección 0x42b000 está el dato 20
Ejemplo:

#include
using namespace std;

int main()
{
    int a = 10, *p, *q;
    p = &a;
    q = p; // la dirección qyue contiene p se asigna a q
    cout << "En la direccion" << q << "esta el valor" << *q << endl;
    }

En la dirección 0x22ff6c está el valor 10
Despues de ejecutarse la asignación q=p, p y q apuntan a la misma localización de memoria, a la variable a. Por lo tanto, a, *p y *q  son el mismo dato; es decir, 10.

No comments: