Introduccin a la Programacin

Semana 9:
Punteros 1
Octubre del 2015

Objetivo
Al finalizar la clase el estudiante debe Entender y operar:

Variables y memoria

Definicin de puntero

Asignar valores a punteros

Arreglos y punteros

Asignar valores y aritmtica de punteros de arreglos

Paso de argumentos por valor y referencia

Arreglos multidimensionales y punteros

Matrices Punteros y Funciones

Variables y memoria
Programa
int n = 35;

Memoria
n
35

0x7ff...c
n;
&n;

Comentario
// identificador de variable
// define y da valor a n
// direccin de n(supuesta)
// = 35
// = 0x7ff...c (& operador de direccin)

Definicin de puntero
Un puntero (por ejemplo ptr) guarda la direccin de otra
variable (por ejemplo n). Tiene dos atributos:
tipo de dato almacenado en n: int, char, etc.
valor
: direccin de n
int *ptr = &n;

// define y da valor a ptr

0x7ff...8
// direccin de ptr (supuesta)
ptr;
// 0x7ff...c = valor de ptr
*ptr;
// 35 = valor de n
* Operador de indireccin: da el valor contenido de la direccin
de memoria apuntada por ptr;
0x7ff ...c

Asignar valores a punteros

Un puntero puede apuntar a cualquier variable de su tipo
int n, k;
int *ptr;
// int *ptr= &n; para asignar valor al definir
ptr = &n;
// ptr = direccin de n
ptr y &n apuntan a la misma direccin.
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 sinnimos:
*ptr = 4 // asigna 4 a n
*ptr += 2 n==6

Asignar valores a punteros

ptr = &k;
// Apunta a k
ptr = NULL;
// ptr no apunta a nada
ptr = 0x3491..; // Se puede, pero no se debe, porqu no se
sabe que hay en la direccin 0x3491...
k; // valor de k
&k // direccin de k
*k // error

ptr; // valor de ptr = direccin de k

&ptr // direccin de ptr
*ptr // valor de k

Puntero constante
int a=10, b=20;

int * const p = &a;

// objeto variable y puntero constante

*p = 15;
p=&b;

// Correcto: El valor apuntado es variable.

// ERROR: p es constante.

Arreglos y Punteros
Programa

Memoria
nn1 2 3

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

0x7ff...a
nn;
nn[0];
nn[1];

Comentario
// identificador de arreglo
// define y da valores
// direccin de inicio (supuesta)
// = 0x7ff...a (direccin)
// = 1
// = 2

Operador sizeof()
sizeof(int);
// 4 (bytes)
sizeof(nn);
// 12 = 3 * 4 = Tamao del arreglo nn
Nmero de elementos de un arreglo: Es responsabilidad del
programador no superar la longitud del arreglo;
nn[3] = 4;
// no da errores de compilacin ni ejecucin

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:

Notacin especial

Notacin de punteros
nn

Valor
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);

int fun(int nn[ ]){

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

int fun(int *nn) {

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

Llama a funcin
Define a funcin

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))++;

Aritmtica de punteros
ptr++;
ptr--;
ptr = ptr + 2;
ptr = ptr * 2;

// Apunta a la siguiente direccin, ver arreglos

// Apunta a la direccin anterior, ver arreglos
// Avanza 2 posiciones, ver arreglos
// Error: Solo acepta sumas y restas

La aritmtica de punteros depende del tipo de puntero,

por ejemplo:
int nn[3] = { 10, 20, 30}, *nnPtr = nn; // int ocupa 4 bytes:
nnPtr++;
nnPtr--;

// es la direccin de 4 bytes ms arriba

// es la direccin de 4 bytes ms 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]);
miFun(var, &varRef, n, nn);
printf("%d, %d, %d, %d\n",var, varRef, n, nn[0]);

// A
// B

}
int miFun(int var, int *varRef, int n, int nn[]){
var
= 5;
// var
NO cambia en main(): paso por valor
*varRef = 6;
// varRef SI cambia en main(): paso por referencia
nn[0] = 7;
// var
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 nmero, dependiendo
del contexto:
char car = b;
printf("%c, %d\n", car, car);
// Resultado: b, 98
98 es el cdigo ascii de b
En el contexto numrico se pueden hacer operaciones aritmticas
siempre que no se salga de los lmites 0 256:
car--;
printf("%c, %d\n", car, car); // Resultado: a, 97
97 es el cdigo ascii de a

Arreglos (string) de caracteres

Al final de un string es obligatorio poner el carcter 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[ ] = {1; 2; 3; 4; 5; 6; 7; 8; 9; \0};
3. char var[10] = 123456789; // El computador agrega NULL
4. char var[ ] = 123456789; // El computador agrega NULL
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,

Matrices Punteros y Funciones

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