PDF de programación - Punteros y arreglos - Programación científica

Programación científica
Punteros y arreglos

Dra. Elisa Schaeffer

[email protected]

PISIS / FIME / UANL

Punteros y arreglos– p. 1

Arreglo

Un arreglo es un conjunto de una cantidad fija de
variables del mismo tipo que se maneja por el mismo
nombre a través de índices:
int elementos[5]; /* ANSI-C */
int i = 3;
int[] elementos = new int[i]; /* Java */

elementos[i] = 4;
Los índices comienzan de cero y terminan en n − 1
donde n es el número total de elementos.

Punteros y arreglos– p. 2

Cayendo afuera: ANSI-C

#include <stdio.c>
int main(int argc, char** args) {

int data[5];
data[5] = 3;
printf("Done.\n");
return 1;

}

Punteros y arreglos– p. 3

@ubuntu$ gcc errores.c
@ubuntu$ ./a.out
Done.
Bus error (core dumped)
@ubuntu$

@yalma$ gcc errores.c
@yalma$ ./a.out
Done.
@yalma$

Reacciones variadas

Punteros y arreglos– p. 4

Cayendo afuera en Java

public class Errores {

public static void main(String[] args) {

int[] data = new int[5];
data[5] = 3;
System.out.println("Done.");
return;

}

}

Punteros y arreglos– p. 5

Reacción consistente

$ java Errores
Exception in thread "main"

java.lang.ArrayIndexOutOfBoundsException: 5

at Errores.main(Errores.java:4)

$

Punteros y arreglos– p. 6

Arreglos multidimensionales

int multi[3][4];
int a, b;

for (a = 0; a < 3; a++) {

for (b = 0; b < 4; b++) {

multi[a][b] = rand() % 7;

}

}
for (a = 0; a < 3; a++) {

for (b = 0; b < 4; b++) {

printf(" %d", multi[a][b]);

}
printf("\n");

}

Punteros y arreglos– p. 7

Puntero

En C, para crear arreglos sacando la capacidad de una
variable, se necesita punteros.
Un puntero es una variable que contiene la dirección a
otra variable en la memoria.
Los punteros son unas maravillas sin los cuales uno lo
logra nada útil en ANSI-C en el largo plazo.

Punteros y arreglos– p. 8

Definición de punteros

#include <stdio.h>
int main(int argc, char** args) {

char* puntero_a_char;
int* puntero_a_int;
char a = ’a’;
int b = 7;
puntero_a_char = &a;
puntero_a_int = &b;
printf("%c %d\n",

*puntero_a_char, *puntero_a_int);

return 1;

}

Punteros y arreglos– p. 9

Notación

*t = puntero a una variable de tipo t
&a = dirección de la variable a
*b = valor apuntado por el puntero b
El compilador queja siempre y cuando uno usa mal esta
notación.

Punteros y arreglos– p. 10

Tamaño de tipo

Al reservar memoria, vamos a recibir un puntero a la
región reservada.
Al reservar, vamos a necesitar saber cuánto espacio
reservar. La función sizeof(tipo) devuelve un entero
que indica cuántos bytes necesita una variable del tipo
definido.
La salida de sizeof() es de tipo size_t que es
simplemente un entero constante sin signo. El espacio
necesario para k variables se calcula por multiplicar: por
ejemplo k*sizeof(int), donde k puede ser constante o
variable.

Punteros y arreglos– p. 11

sizeof()

#include <stdio.h>
int main(int argc, char** args) {
size_t charsize = sizeof(char);
size_t intsize = sizeof(int);
size_t longsize = sizeof(long);
size_t floatsize = sizeof(float);
size_t doublesize = sizeof(double);

printf("char %d, int %d, long %d, float %d, double %d\n",

charsize, intsize, longsize, floatsize, doublesize);

return 1;

}

Salida: char 1, int 4, long 4, float 4, double 8

Punteros y arreglos– p. 12

Reservación de memoria

void* malloc(size_t n)
= reservar n bytes de memoria
void* cealloc(size_t n)
= reservar e inicializar a cero
void* realloc(void* p, size_t n)
= aumentar la región
free(void* p)
= liberar el espacio apuntado por el puntero

Punteros y arreglos– p. 13

Conversión de void

Las salidas son tipo void .
Para asignar la salida de malloc() a un int ∗, por
ejemplo, hay que hacer conversión explícita (inglés: type
casting):

int* d = (int*)malloc(7*sizeof(int));
m/c/realloc da la salida NULL si la operación no es
éxitosa. Es importante verificar esto en cada programa.
Son de la librería stdlib.h .

Punteros y arreglos– p. 14

Punteros a punteros

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** args) {

int i, j, h, k = 4;
int*** tresd = (int***)malloc(sizeof(int**)*k);
for (i = 0; i < k; i++) {

tresd[i] = (int**)malloc(sizeof(int*)*(k-1));
for (j = 0; j < k - 1; j++) {

tresd[i][j] = (int*)malloc(sizeof(int)*(k-2));
for (h = 0; h < k - 2; h++) {

tresd[i][j][h] = rand() % 10;

}

}

}
return 1;

}

Punteros y arreglos– p. 15

Lo que imprime el programa anterior:

1 2
6 0
8 7
3 7

7 0
6 2
9 2
5 9

9 3
6 1
0 2
2 2

Nota: falta verificar el resultado de malloc()

¿Resultado?

Punteros y arreglos– p. 16

string.h

char* strcpy(char*, char*)
copiar el segundo al primero

char* strcat(char*, char*)
juntar dos en uno

int strcmp(char*, char*)
comparar (antes, igual, después)

char* strchr(char*, int)
la primera ocurrencia de un símbolo

char* strstr(char*, char*)
primera ocurrencia de otra cadena

size_t strlen(char*)
largo (número de símbolos “ocupados”)

La librería string.h
permite
realizar
varias
operaciones
con arreglos de char
o punteros a char .
La lista muestra una
pequeñ parte.

Punteros y arreglos– p. 17

Puntero a función

Funciones que dan el mismo tipo de salida y toman los
mismos tipos de parámetros se puede manejar a
través de un puntero de ese “prototipo”:
double multiply(int a, double b) {

printf("%.4f\n", b*a);
return b*a;

}

typedef double (*funpoint)(int, double);

Punteros y arreglos– p. 18

Uso de punteros a funciones

Tres maneras de llamar la misma función:

funpoint fp = &multiply;

multiply(3, 1.2);
(*fp)(3, 1.2);
fp(3, 1.2);

Punteros y arreglos– p. 19

Función como parámetro

#include <stdio.h> // printf()
#include <stdlib.h> // RAND\_MAX
... // lo de la dispositiva anterior

void task(funpoint f) {

int first = rand() % 7;
double second = (rand()*1.0)/RAND\_MAX;
f(first, second);
return;

}
int main(int argc, char** args) {

funpoint fp = &multiply;
task(fp);
return 1;

}

Punteros y arreglos– p. 20