Вы находитесь на странице: 1из 15
Introducción a la Programación Semana 9: Punteros 1 Octubre del 2015

Introducción a la Programación

Semana 9:

Punteros 1

Octubre del 2015

Objetivo

Al finalizar la clase el estudiante debe Entender y operar:

Variables y memoria

Definición de puntero

Asignar valores a punteros

Arreglos y punteros

Asignar valores y aritmética de punteros de arreglos

Paso de argumentos por valor y referencia

Arreglos multidimensionales y punteros

Matrices Punteros y Funciones

Variables y memoria

Programa

Memoria

Comentario

n

// identificador de variable

int n = 35;

35
35

// define y da valor a n

0x7ff

c

// dirección de n(supuesta)

n;

// = 35

&n;

// = 0x7ff

c

(& operador de dirección)

Definición de puntero Un puntero (por ejemplo ptr) guarda la dirección de otra variable (por ejemplo n). Tiene dos atributos:

tipo de dato almacenado en n: int, char, etc.

valor

: dirección de n

int *ptr = &n;

0x7ff

c

//

define y da valor a ptr

0x7ff

8

//

dirección de ptr (supuesta)

ptr;

//

0x7ff

c

= valor de ptr

*ptr;

//

35 = valor de n

* Operador de indirección: da el valor contenido de la dirección

de memoria apuntada por ptr;

Asignar valores a punteros

Un puntero puede apuntar a cualquier variable de su tipo int n, k; int *ptr;

// int *ptr= &n; ptr = &n;

para asignar valor al definir // ptr = dirección de n

ptr y &n apuntan a la misma dirección.

ptr puede cambiar a otra variable del mismo tipo:

ptr = &k;

ptr++; // ya no apunta a n

&n no puede cambiar

Mientras ptr apunte a n: *ptr y n son sinónimos:

*ptr = 4 // asigna 4 a n

*ptr += 2

→ n==6

Asignar valores a punteros

ptr = &k; ptr = NULL; ptr = 0x3491

;

// Apunta a k // ptr no apunta a nada // Se puede, pero no se debe, porqué no se sabe que hay en la dirección 0x3491

k;

&k // dirección de k

*k

// valor de k

// error

ptr;

// valor de ptr = dirección de k

&ptr

// dirección de ptr

*ptr

// valor de k

Puntero constante

int a=10, b=20;

int * const p = &a;

*p = 15; p=&b;

// objeto variable y puntero constante

// Correcto: El valor apuntado es variable. // ERROR: p es constante.

Arreglos y Punteros

Programa

int nn[3] = {1,2,3};

Memoria nn 1 2 3 0x7ff a
Memoria
nn
1
2
3
0x7ff
a

Comentario // identificador de arreglo // define y da valores

// dirección de inicio (supuesta)

nn;

//

= 0x7ff

a

(dirección)

nn[0];

//

= 1

nn[1];

//

= 2

Operador sizeof() sizeof(int); sizeof(nn);

// 4 (bytes) // 12 = 3 * 4 = Tamaño del arreglo nn

Número de elementos de un arreglo: Es responsabilidad del programador no superar la longitud del arreglo;

nn[3] = 4;

// no da errores de compilación ni ejecución

Dos modos de operar Arreglos

Definir y usar arreglos:

int nn[3]; int nn[3] = {10, 20, 30};

// Definir sin valores // Definir con valores:

Un arreglo -puntero- se maneja de 2 modos equivalentes:

Notación especial

Notación de punteros

Valor

 

nn

0x7ff

a

nn[0];

*nn;

10

nn[1];

*(nn+1);

20

nn[2];

*(nn+2);

30

nn[1] = 80;

*(nn+1) = 80;

80

n = fun(nn);

n = fun(nn);

Llama a función

int fun(int nn[ ]){ nn[1] = 2; *(nn+2) = 3;}

int fun(int *nn) { *(nn+1) = 2; nn[2] = 3;}

Define a función

Asignar valores a punteros de arreglos

int nn[3] = {10, 20 ,30}, *ptrNN;

ptrNN = nn;

// no es necesario & (como en las variables).

Mientras ptrNN apunte a nn son equivalentes por completo:

nn[i];

*(nn+i); ptrNN[i];

*(ptrNN+i);

Por ejemplo, aumente 1 a nn[2] en 4 formas:

nn[2]++;

(*(nn+2))++;

ptrNN[2]++;

(*(ptrNN+2))++;

Aritmética de punteros

ptr++;

// Apunta a la siguiente dirección, ver arreglos

ptr--;

// Apunta a la dirección anterior, ver arreglos

ptr =

ptr + 2;

// Avanza 2 posiciones, ver arreglos

ptr =

ptr * 2;

// Error: Solo acepta sumas y restas

La aritmética de punteros depende del tipo de puntero, por ejemplo:

int nn[3] = { 10, 20, 30}, *nnPtr = nn;

// int ocupa 4 bytes:

nnPtr++;

// es la dirección de 4 bytes más arriba

nnPtr--;

// es la dirección de 4 bytes más abajo.

Paso de argumentos por valor y referencia

void main(void){ int var = 1, varRef = 2; int n = 3, nn[3] = {10, 20, 30};

// longitud del arreglo y arreglo

printf("%d, %d, %d, %d\n",var, varRef, n, nn[0]);

// A

miFun(var, &varRef, n, nn); printf("%d, %d, %d, %d\n",var, varRef, n, nn[0]);

// B

}

int miFun(int var, int *varRef, int n, int nn[]){

var

*varRef = 6;

= 5;

}

nn[0]

= 7;

// var

// varRef SI cambia en main(): paso por referencia

// var

NO cambia en main(): paso por valor

SI cambia en main(): paso por referencia

Resultados de printf en A y B:

// A: 1, 2, 3, 10 // B: 1, 6, 3, 7

Variables tipo char

Las variable tipo char funcionan como char o número, dependiendo del contexto:

char car = ‘b’;

printf("%c, %d\n", car, car);

// Resultado: b, 98 98 es el código ascii de b

En el contexto numérico se pueden hacer operaciones aritméticas siempre que no se salga de los límites 0 – 256:

car--;

printf("%c, %d\n", car, car);

// Resultado: a, 97 97 es el código ascii de a

Arreglos (string) de caracteres

Al final de un string es obligatorio poner el carácter NULL (‘\0’).

Las siguientes 4 sentencias son equivalentes:

1. char var[10] = {‘1’; ‘2’; ‘3’; ‘4’; ‘5’; ‘6’; ‘7’; ‘8’; ‘9’; ‘\0’};

2. char var[ ]

3. char var[10] = “123456789”; // El computador agrega NULL

= “123456789”; // El computador agrega NULL

4. char var[ ]

= {‘1’; ‘2’; ‘3’; ‘4’; ‘5’; ‘6’; ‘7’; ‘8’; ‘9’; ‘\0’};

scanf(“%s”, var);

// El usuario ingresa: abc<enter> El computador agrega NULL.

Arreglos multidimensionales y Punteros

Imprimir una matriz:

1, 2, 3, 4, 5, 6, 7, 8, 9,

Arreglos multidimensionales y Punteros Imprimir una matriz: 1, 2, 3, 4, 5, 6, 7, 8, 9,

Matrices Punteros y Funciones

Imprimir una matriz:

a, b, c, d, e, f, g, h, i, de dos modos diferentes:

Matrices Punteros y Funciones Imprimir una matriz: a, b, c, d, e, f, g, h, i,