clase punt eros
Post on 14-Aug-2015
38 Views
Preview:
TRANSCRIPT
Variables• Una variable es una porción de memoria identificada por un nombre.
• El tipo de dato define su representación binaria y longitud.
• Tiene tres valores asociados: Nombre, Contenido y Dirección.
Declaramos: “int n=1523, m=121;”
Contenido:– n 1523
– m 121
Dirección: – &n C102
– &m C100
• Es contenido binario se codifica (bits) de acuerdo al tipo de variable.
0000000 01111001 00000101 11110011
Dirección: C100 Dirección: C102
Valor: 121 Valor: 1523
m n
Punteros
• Un puntero es una variable que hace referencia a una dirección
de memoria
Sintaxis declaracion:
Tipo_Dato *nombre_variable_puntero;
Ejemplo:
int *p;
Sintaxis Asignación de Dirección
nombre_puntero=&variable;
Punteros
• Declaración
• Puntero a un Tipo de Dato
int* pInt;
char* pChar;
Con la declaración , estamos instruyendo al compilador para que sepa que
la variable pInt almacenará una dirección de memoria (será un puntero). Se
lleva a cabo mediante el tipo de dato “pointer” ó “puntero a entero”.
Esto, le indica al compilador como debe interpretar los bytes ubicados en la
dirección en cuestión (en el caso de pInt como Entero y en el caso
de pChar como char).
Punteros
Los punteros son variables, por lo que se los modela como tales, es
decir: cajas contenedoras con un nombre asociado. La diferencia
esta en la diagramación de su contenido, el cual bien podría ser una
dirección de memoria ($FA00:4567) pero sería muy confuso
trabajarlo. En lugar de ello, se suele representar con flechas que
llegan a la dirección de memoria a la cual apuntan.
“pChar” y “p”
apuntan a la misma
variable “A”.
Punteros• Un puntero es una variable cuyo contenido es una dirección.
• Como todas las variable tiene nombre, contenido y dirección.
• Un puntero “apunta a”: un dato, un array, un objeto, una función, etc.
int n; //declara una variable entera (16 bits / 2 bytes)
int *j; // declara un puntero tipo entero (solo almacena direcciones).
j //contiene una dirección donde comienza un entero.
*j //valor entero almacenado en la dirección apuntada por “j” (indirección).
• n contenido=“valor del entero” j contenido=“valor de la dirección”.
• &n dirección del entero en “n” *j contenido en la dirección de “j”.
Valor *j=n 40j0xA010
Dirección: &j0xF234 Dirección: j &n 0xA010
Lugar: 2 byte donde esta
almacenado j
Lugar: 2 byte donde esta
almacenado n
Representamos “int n=40, *j=&n;” suponemos que se almacenan:
n en la dirección 0xA010 y j en la dirección 0xF234
int a=1, b=2, *p;
Las variables a,b,p están almacenadas e memoria como:
a b p
?
Pensamos en p como una flecha. Pero como no se le ha asignado un valor no sabemos a que apunta.
Si escribimos p= &a;
Esto lo leemos como “a p se le asigna la dirección de a” y el diagrama sería:
1 2
Punteros
Diagrama nuevo:
a b p
Ahora hacemos la asignación: b= *p;
Que se lee “a la variable b se le asigna el valor a que apunta p”, y
como p apunta hacia a,
b = *p; es equivalente a b = a;
1 2
#include <stdio.h>
main()
{
int i = 7, *p ; /* variable p de tipo entero */
p = &i; /* p apunta a la dirección de i */
cout<< “Valor de i :”<< *p,
cout<<“Localizacion de i: “<< p;
cout<<“”Valor de i <<i;
cout<<“Localizacion de i = “<<&i;
}
Un programa que ilustra la distinción p = &a, y b =*p es:
Lo que se lee en la pantalla es:
Valor de i : 7
Localización de i : effffb24
Valor de i : 7
Localización de i : effffb24
7
i p
effffb24 x
Nombre variable
Contenido
Dirección
effffb24 ?
Punteros
El carácter & delante de una variable indica que lose está accediendo es a la dirección de memoriade dicha variable.
Ejemplo:
int *p,i;
p=0; /* p posee la dirección NULL ó 0*/
p=NULL; /* p posee la dirección NULL ó 0*/
p=&i; /*p apunta hacia i ó conteniendo la dirección de i */
7
i p
effffb24
effffb24
Punteros
" Si p es un puntero, entonces *p es el valorde la variable a la que apunta .“
Ejemplo:
double x,y,*p;
p=&x;
y=*p;
Lo anterior es equivalente a :
y=*&x;
y=x;
y p
1
x
effffb24
effffb241
Punteros
Inicialización
Sintaxis:
tipo_dato *nombre_puntero=&variable;
Ejemplo:
int i=7,*p=&i;
Punteros
int k = 0; //variable entera
int *p = NULL; // puntero a entero
k = 15;
p = &k; // p apunta a k
Punteros
El espacio de memoria reservado para
almacenar un puntero es el mismo
independientemente del tipo de dato al
que apunte:
char c = ‟a‟;
char *ptrc;
int *ptri;
Punteros - Operadores
OPERADOR DE DIRECCION
Operador &
• &<id> devuelve la dirección de memoria donde
comienza la variable <id>.
• El operador & se utiliza para asignar valores a datos de
tipo puntero:
int y =5;
int *ptrY;
ptrY=&y;
5
ptrY Y
60000 5
ptrY Y
50000 60000
Punteros - OperadoresOPERADOR DE INDIRECCION
Operador *
• *<ptr> devuelve el contenido del objeto referenciado
por el puntero <ptr>.
• El operador * se usa para acceder a los objetos a los
que apunta un puntero:
char c;
char *ptr;
…
ptr = &c;
*ptr = „A‟; // Equivale a escribir: c = „A‟
ptr c
60000
ptr c
50000 60000
60000 A
ptr c
50000 60000
Punteros - OperadoresOPERADOR DE ASIGNACION
Operador =
• A un puntero se le puede asignar una dirección de
memoria concreta, la dirección de una variable o el
contenido de otro puntero.
• Ej : Una dirección de memoria concreta:int *ptr;
...
ptr = 0x1F3CE00A;
...
ptr = NULL;
OPERADOR DE ASIGNACION
Operador =
• La dirección de una variable del tipo al
que apunta el puntero:
char c;
char *ptr;
...
ptr = &c;
Punteros - Operadores
Punteros - OperadoresOPERADOR DE ASIGNACION
Operador =
• Otro puntero del mismo tipo:
char c;
char *ptr1;
char *ptr2;
…
ptr1 = &c;
ptr2 = ptr1;
• Como todas las variables, los punteros también contienen
“basura” cuando se declaran, por lo que es una buena
costumbre inicializarlos con NULL.
Punteros - Operadores
Operador Nombre Descripción
* Operador
Indirección
Me da el valor que esta
almacenado en una dirección
de memoria.
También sirve para declarar
una variable apuntador
& Operador
Dirección
Me da la dirección de
memoria de una variable
#include<iostream.h>
main()
{
int a ;
int *ptra;
a=7;
ptra=&a;
cout<<"la direccion de a es "<<&a<<endl;
cout<<"el valor de ptra es "<<ptra;
cout<<"el valor de a es "<<a<<endl;
cout<<"el valor de *ptra es "<<*ptra<<endl;
system("pause");
}
Punteros - Operadoresptra A
7
ptra A
50000 60000
60000 7
ptra A
50000 60000
PunterosErrores comunes
• Asignar punteros de distinto tipo
int a = 10;
int *ptri = NULL;
double x = 5.0;
double *ptrf = NULL;
...
ptri = &a;
ptrf = &x;
ptrf = ptri; // ERROR
cannot convert `double*' to `int*' in
assignment
PunterosErrores Comunes
• Utilizar punteros no inicializados
char *ptr;
*ptr = „a‟; // ERROR
• Asignar valores a un puntero y no a la variable a la que apunta
int n;
int *ptr = &n;
ptr = 9; // ERROR
• Intentar asignarle un valor al dato apuntado por un puntero cuando éste es NULL
int *ptr = NULL;
*ptr = 9; // ERROR
invalid conversion from `int' to `int*'
Provoca la excepción de violación de
acceso de memoria (segmentation fault) y
detiene el programa.
top related