Almacenamiento Dinámico

Los Punteros
 Intercambio con error ¿porqué?
#include <stdio.h>
void intercambio(int, int); /* prototipo */
main(){
int a=1,b=2;
printf("a=%d b=%d\n",a,b);
intercambio(a,b); /* llamada */
Porque
printf("a=%d se pasan parámetros por valor!!
b=%d\n",a,b);
return 0;
}
Solución: pasar parámetros
void intercambio(int x, int y){
por referencia!
/* declaración formal */
int temp;
temp=x;
=> usar punteros !!
x=y;
y=temp;
printf(“ x=%d y=%d\n“,x,y);
}

1
 Definición y operador &

• Puntero es una variable cuyo contenido es la dirección de una

variable. (apunta a una variable)
• Ejemplo: sea p una variable de tipo puntero y c una variable de
cualquier tipo:

p: c:
...... .......

p = &c;

El operador unario & entrega la dirección del objeto que le sucede.

 Operador *
• El operador unario *, permite el acceso al contenido de la
dirección apuntada por la variable puntero que le sucede.
• Ofrece un nombre alternativo para la variable apuntada.
• Sean c y f dos variables enteras, sea p una variable puntero que
“apunta a c”.

p: c: f:
...... ....... 2 3
*p = 2;
f =*p + 1;
Es lo mismo que: c = 2;
f = c + 1;
 Ejemplo

int x = 1, y = 2;
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
y = *ip; /* y es ahora 1 */
*ip = 0; /* x es ahora 0 */
 Ejemplo (cont.)

int x = 1, y = 2;
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
y = *ip; /* y es ahora 1 */
*ip = 0; /* x es ahora 0 */

x: y:
...... ....... 1 2
1
 Ejemplo (cont.)

int x = 1, y = 2;
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
y = *ip; /* y es ahora 1 */
*ip = 0; /* x es ahora 0 */

ip: x: y:
...... ? ....... 1 2
1
 Ejemplo (cont.)

int x = 1, y = 2;
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
y = *ip; /* y es ahora 1 */
*ip = 0; /* x es ahora 0 */

ip: x: y:
...... ....... 1 2
1
 Ejemplo (cont.)

int x = 1, y = 2;
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
y = *ip; /* y es ahora 1 */
*ip = 0; /* x es ahora 0 */
El operador unario * es el operador de indirección.

ip: x: y:
...... ....... 1 1
 Ejemplo (fin)

int x = 1, y = 2;
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
y = *ip; /* y es ahora 1 */
*ip = 0; /* x es ahora 0 */
El operador unario * es el operador de indirección.

ip: x: y:
...... ....... 0 1
1
 Aritmética de punteros

• El contenido de un puntero puede ser modificado realizando

operaciones aritméticas enteras simples.

float *p; / * un float tiene 4 bytes */

p = p + 2; /* p apunta ahora a una variable
2*4 bytes de distancia del la anterior */

p:
...... .......

1 byte 1 float
Aritmética de punteros (ejemplo)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */
 Aritmética de punteros (cont.)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

x: y: z:
...... ....... 0 1 2
 Aritmética de punteros (cont.)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

ip: x: y: z:
...... ? ....... 0 1 2
 Aritmética de punteros (cont.)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

ip: x: y: z:
...... ....... 0 1 2
 Aritmética de punteros (cont.)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

ip: x: y: z:
...... ....... 1 1 2
 Aritmética de punteros (cont.)
Int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

ip: x: y: z:
...... ....... 0 1 2
 Aritmética de punteros (cont.)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

ip: x: y: z:
...... ....... 0 2 2
 Aritmética de punteros (cont.)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

ip: x: y: z:
...... ....... 0 2 2
 Aritmética de punteros (fin)
int x = 0, y = 1, z = 2;/* globales */
int *ip; /* ip es puntero a entero */
ip = &x; /* ip apunta al entero x */
*ip = *ip + 1; /* x es ahora 1 */
ip = ip + 1; /* ip apunta ahora a y */
*ip = *ip + 1; /* y es ahora 2 */
ip = ip + 1; /* ip apunta ahora a z */
*ip = *ip + 1; /* z es ahora 3 */

ip: x: y: z:
...... ....... 0 2 3
 Otra imagen de punteros

ip: x: y: z:
...... ....... 0 2 3
Otra imágen de punteros

ip

x: y: z:
........................ 0 2 3
 Intercambio sin error
#include <stdio.h>
void intercambio(int *, int *); /* prototipo */
int main(){
int a=1,b=2;
printf("a=%d b=%d\n",a,b);
intercambio(&a,&b); /* llamada */
printf("a=%d b=%d\n",a,b);
return 0;
}
void intercambio(int *x, int *y){ /* declaración formal */
int temp;
temp=*x; // *x, *y son nombres alternativos de a y b
*x=*y;
*y=temp;
}