|


  

Ing. Betty Suárez Torres

|

 
|



„n puntero es una x
 Ôomo Ôualquier otra, Ôontiene una



que apunta a otra posiÔión en memoria, en esa posiÔión se
almaÔenan los datos a los que apunta el puntero, es deÔir, un
puntero apunta a una variable de memoria

^  
`l igual que Ôualquier variable, las variables punteros han de ser
deÔlaradas antes de utilizarlas. La deÔlaraÔión de una variable
puntero debe indiÔar al Ôompilador el tipo de dato al que apunta el
puntero; para ello se haÔe preÔeder a su nombre Ôon un asterisÔo
(*), mediante el siguiente formato:
   !" # !
`lgunos ejemplos de variables punteros:
int* ptrl; //Puntero a un tipo de dato entero (int)
long* ptr2; //Puntero a un tipo de dato entero largo (long int)
Ôhar* ptr3; //Puntero a un tipo de dato Ôhar
float *f; //Puntero a un tipo de dato float
|

 %&'^|


La iniÔializaÔión de un puntero proporÔiona a ese puntero la direÔÔión del dato

Ôorrespondiente. Después de la iniÔializaÔión, se puede utilizar el puntero para
referenÔiar los datos direÔÔionados. Para asignar una direÔÔión de memoria a
un puntero se utiliza el operador de referenÔia &. por ejemplo: &valor
signifiÔa «la direÔÔión de valor».
El método de iniÔializaÔión (iniÔiaÔión), también denominado  requiere:
o `signar memoria (estátiÔamente) definiendo una variable y a ÔontinuaÔión
haÔer que el puntero apunte al valor de la variable.
( ))# *  +
"( ))# 
,-( )) 
   
o `signar un valor a la direÔÔión de memoria: ",./
El asterisÔo delante de la variable puntero indiÔa ü

de la
memoria apuntada por el puntero y será del tipo dado.
No se puede liberar la memoria reservada para una variable. El puntero a esa
variable se puede Ôambiar, pero permaneÔerá la Ôantidad de memoria
reservada.

|
$

| ^
^^ '-

&<var> devuelve la direÔÔión de memoria donde

empieza la variable <var>.
 -1 2 + 3  

 *   4
int i, *ptri;
ptri = &i;
i es una variable de tipo entero, por lo que la
expresión &i es la direÔÔión de memoria donde
Ôomienza un entero y, por tanto, puede ser asignada
al puntero ptri.
Se diÔe que ptri 
 o


 a i.

|
0

| ^
^^ '"

*<puntero> devuelve el Ôontenido del objeto

referenÔiado por
<puntero>.
Ôhar Ô, *ptrÔ;
ptrÔ = &Ô;
*ptrÔ = ¶`¶; x 
 
ptrÔ es un puntero a ÔaraÔter que Ôontiene la
direÔÔión de Ô, por tanto, la expresión *ptrÔ es el
objeto apuntado por el puntero, es deÔir, Ô.
„n puntero Ôontiene una direÔÔión de memoria y se
puede interpretar Ôomo un número entero aunque un
puntero no es un número entero. No obstante existen
un Ôonjunto de operadores que se pueden realizar
sobre un puntero:
+,-,++,±, !=, ==
|
.
 67|%

linÔlude <stdio.h>
linÔlude <Ôonio.h>
Ôhar Ô; //variable global de tipo ÔaráÔter
void main(){
Ôhar *pÔ; //un puntero a una variable ÔaráÔter*/
pÔ = &Ô;
for (Ô='`';Ô<='Z';Ô++){
printf ("%Ô",*pÔ) ;
}
getÔh(); }
La ejeÔuÔión de este programa visualiza el alfabeto. La variable
puntero pÔ es un puntero a una
variable ÔaráÔter. La línea pÔ = &Ô asigna a pÔ la direÔÔión de la
variable Ô (&Ô) . El buÔle for almaÔena en Ô las letras del alfabeto y la
sentenÔia print f ( "%Ô" , *pÔ ) ; visualiza el Ôontenido de la variable
apuntada por pÔ.

|
5
67|%

|
8

| ^
^|


|
9
 

7

o 
 
int a=10, *ptri;
float b=5.0, *ptrf;
ptri = &a;
ptrf = &b;
ptrf = ptri; 



 

o  1 

Es un error asignar un valor, a un Ôontenido de una variable puntero
si previamente no se ha iniÔializado Ôon la direÔÔión de una
variable, o bien se le ha asignado dinámiÔamente memoria (malloÔ /
new). Por ejemplo:
float* px;
*px = 23.5; //error, px no Ôontiene direÔÔión
o 
 *  ;  *  +.
Ôhar y=5, *nptr =&y; //CORRECTO
nptr = 9; 

|
:
 67|%

linÔlude <stdio.h>
void main(){
int n = 75;
<
n = 45 //visualiza el valor de n
printf("n= %d\n",n) ;
&n =
=0###$0
//visualiza
0x4 f f f d3 0es una direÔÔión deÔódigo
direÔÔión en n
printf("&n= %p\n",&n);
hexadeÔimal.
³Ox"
} es el prefijo Ôorrespondiente al Ôódigo
hexadeÔimal.

|
/
 67|%

6'
linÔlude <stdio.h>
n= 75, &n=
linÔlude 0012FFF6C, p= 0012FFF6C, &p=
<Ôonio.h>
void main(){
0012FF70
int n = 75;0012FF70 0012FFF6C
//*p variable puntero, tiene direÔÔión de n
0012FFF6C n
int* pp = &n; 75
printf("n = %d,
int *&n = %p, p = %p\n",n,&n,p);
int
printf ("&p = %p\n",&p);
getÔh();
}

|

  >%
|


„n nombre de un array es simplemente un

puntero. Supongamos que se tiene la siguiente
deÔlaraÔión de un array:
int lista[5] = {10, 20, 30, 40, 50};

0 10 lista + 0 lista[0] (*lista)

1 20 lista + 1 lista[1]
lista 2 lista + 2 lista[2]
30
3 40 lista + 3 lista[3]
4 50 lista + 4 lista[4]
|

 67|%

int v[0] ;
int *p;
p = v;
(v+4); //apunta al 5" elemento
p = p+6; //Ôontiene la direÔÔión del elemento
una variable puntero se le puede apliÔar el
operador ++, o el operador - - . Esto haÔe que
Ôontenga la direÔÔión del siguiente o anterior
elemento:
float m[20];
float *r;
r = m;
r++; //Ôontiene la direÔÔión del elemento
siguiente |
$
 |
^

Los punteros se pueden utilizar en lugar de índiÔes de arrays. Ejemplo:

Ôhar alfabeto [27] = ³`BCDEFGHIJKLMNOPQRST„
Z";
DeÔlaremos ahora p un puntero a Ôhar
Ôhar *p;
Se estableÔe que P apunta al primer ÔaráÔter de alfabeto esÔribiendo
p = &alfabeto[0]; //o también p = alfabeto
de modo que si esÔribe la sentenÔia
printf("%Ô \n", *p) ;
se visualiza la letra `, ya que p apunta al primer elemento de la
Ôadena. Se puede haÔer también
p = alfabeto[15];
de modo que p apuntará al ÔaráÔter 5?(la letra Q). Sin embargo, no
se puede haÔer
p = &alfabeto;
ya que alfabeto es un array Ôuyos elementos son de tipo Ôhar, y se
produÔiría un error al Ôompilar (tipo de asignaÔión es inÔompatible).
|
0
 |

7
 >7


Cuando se pasa una variable a una funÔión (p 


x 
no se puede Ôambiar el valor de esa variable. Sin
embargo, si se pasa un puntero a una variable a una
funÔión  


se puede Ôambiar el valor de
la variable. Ejemplo:
Considere la siguiente definiÔión de la funÔión i3 
@3  *  +.4
void InÔrementar(int *i){
*i += 5;
}
Π     



int i;
i = 10;
InÔrementar(&i) ;
|
.
 67|%

 

struÔt temperatura{
float alta;
float baja ;
};
void registrotemp(struÔt temperatura *t){
float aÔtual ;
leertempaÔtual(aÔtual);
if (aÔtual > t -> alta)
t - > alta = aÔtual;
else if (aÔtual < t -> baja)
t -> baja = aÔtual;
}
La llamada a la funÔión sería:
struÔt temperatura tmp;
registrotemp(&tmp);

|
5
 67|%

linÔlude <stdio.h>
linÔlude <Ôonio.h>
struÔt persona{ void mostrar_persona(persona *ptr){
Ôhar nombre [30]; printf ("\nNombre : %s\n",ptr -> nombre) ;
int edad; printf ("\tEdad: %d\n", ptr -> edad);
float altura; printf ("\t`ltura: %f\n",ptr -> altura) ;
int peso; printf ("\tPeso: %d\n",ptr -> peso);
}
};
typedef struÔt persona persona;
void mostrar_persona(persona *ptr);
void main(){
int i;
persona empleados [ ] = {{"Juan Perez", 47, 1.82, 85}, {"Luis GarÔía", 39, 1.70,
75}, {"Tomás Jimenez",18, 1.75, 80}} ;
persona *p; //puntero a estruÔtura
p = empleados;
for (i = 0; i < 3;i++, p++){
mostrar_persona(p);
}
getÔh(); }
|
8
 A%'

EnÔuentra los errores en la siguiente

deÔlaraÔión de punteros:
int x, *p, &y;
Ôhar *b = ³Cadena larga´;
Ôhar* Ô= µC¶;
float x;
void *r = &x;

|
9