El Lenguaje de Programación C (Pt. 2) Organización de Computadoras Depto. Cs. e Ing. de la Comp. Universidad Nacional del Sur

Transcripción

1 El Lenguaje de Programación C (Pt. 2) Organización de Computadoras Depto. Cs. e Ing. de la Comp. Universidad Nacional del Sur

2 Organización de Computadoras 2 Copyright Copyright A. G. Stankevicius Se asegura la libertad para copiar, distribuir y modificar este documento de acuerdo a los términos de la GNU Free Documentation License, Versión 1.2 o cualquiera posterior publicada por la Free Software Foundation, sin secciones invariantes ni textos de cubierta delantera o trasera. Una copia de esta licencia está siempre disponible en la página

3 Organización de Computadoras 3 Contenidos Introducción al paradigma imperativo. Sentencias de control. Entrada y salida estándar. Pasaje de parámetros. Tipos de datos estructurados. Gestión de la memoria dinámica. Estructuras de datos dinámicas. Gestión de archivos.

4 Organización de Computadoras 4 Punteros Las variables declaradas de tipo puntero representan direcciones de memoria. En todo momento se debe tener clara la diferencia entre una variable de tipo puntero y el dato alojado en la dirección por él apuntada. Los punteros se declaran con un asterisco delante del identificador de la variable: int *px, y; /* px es un puntero e y es un entero */

5 Organización de Computadoras 5 Operaciones sobre punteros En relación a los punteros, existen dos operadores fundamentales: Desreferenciamiento: si px es un puntero, la expresión *px denota al contenido apuntado por el puntero (es decir, el valor almacenado en la dirección referenciada por el puntero). Enreferenciamiento: si x es una variable, la expresión &x denota a la dirección de memoria donde se encuentra almacenado el valor de x.

6 Organización de Computadoras 6 Operaciones sobre punteros int x = 10, y = 5; int *px; 1000: 1001: 1002: 10 5? int x int y int *px px = &x; *px = &y; 1000: 1001: 1002: int x int y int *px px = 1234; // tendrá sentido?

7 Organización de Computadoras 7 Aritmética sobre punteros Los punteros se comportan como cualquier otra tipo elemental, es decir, admiten toda la gama de operaciones aritméticas. La clave para entender esto radica en que los punteros almacenan en esencia direcciones de memoria, en otras palabras, enteros positivos. Las operaciones aritméticas se comportan de manera inteligente, teniendo en cuenta el tipo base al cual apuntan los punteros.

8 Organización de Computadoras 8 Aritmética sobre punteros int vector[5] = {10, 20, 30, 40, 50}; int *pv = vector; // aquí, qué denota *pv? *pv = 15; *(pv + 3) += 5; // y aquí? char string[250] = {'M', 'a', 'r', 'í', 'a'}; char *ps = &string[2]; *(ps + 2) = 'o'; // en qué cambió string?

9 Organización de Computadoras 9 Pasaje por referencia Los punteros permiten simular un pasaje de parámetros por referencia: int reset(int *a, int b) { } *a = 0; b = 0; // *a y b son reseteados. void main() { } int x = 1, y = 1; reset(&x, y); // x vale 0, pero y vale 1.

10 Organización de Computadoras 10 Pasaje por referencia int a = 10, b = 20; void cambiar(int p, int *q) { } p += 2; *q += p; int main () { } cambiar(a, &b); printf( a vale %i y b vale %i, a, b);

11 Organización de Computadoras 11 Punteros genéricos Para declarar un puntero genérico, el cual sea capaz de apuntar datos de distintos tipos, se debe apelar al tipo void. Este tipo solo puede figurar como tipo base de un punteros, es decir, declarar a una variable común de tipo void carece de sentido. void *px; // válido. void x; // inválido.

12 Organización de Computadoras 12 Definición de arreglos La definición de arreglos y matrices se realiza indicando las dimensiones entre corchetes: // un arreglo de 25 enteros int a[25] // una matriz de reales de 4x4 float vx[4][4]; // un arreglo de carácteres char string[250];

13 Organización de Computadoras 13 Indexado de arreglos A diferencia de otros lenguajes, en C la primer componente de un arreglo ocupa la posición 0: int i, vector[10]; for (i = 0; i < 10; i++) { // empieza en 0 } vector[i] = i; // y termina en 9!

14 Organización de Computadoras 14 Inicialización de arreglos Los arreglos en C pueden inicializarse al mismo tiempo que son definidos: int vector[5] = {0, 1, 2, 3, 4}; int matrix[2][3] = { {1, 2, 3}, char cadena1[250] = {4, 5, 6} }; {'H', 'o', 'l', 'a', '!'}; char cadena2[250] = Hola! ; // será cadena1 == cadena2?

15 Organización de Computadoras 15 Cadenas de caracteres En este lenguaje las cadenas de caracteres son simples arreglos de caracteres que terminan en un caracter nulo ('\0'): char cadena1[250] = {'H', 'o', 'l', 'a', '!', '\0'}; char cadena2[250] = Hola! ; /* ahora cadena1 y cadena2 resultan equivalentes. */

16 Organización de Computadoras 16 Asignación de arreglos El operador de asignación no puede utilizarse con arreglos ni con cadenas de caracteres. int a[5], b[5]; a[0] = 1; a[2] = 3; b = a; // Error! No confundir con la inicialización de arreglos, la cual si está permitida: int c[5] = {0, 3, 2, 0, 0};

17 Organización de Computadoras 17 Funciones de librería C dispone de una gran cantidad de funciones de librería sobre cadenas de caracteres (presentes en la librería strings): strcat(): para concatenar strings. strcpy(): para copiar strings. strcmp(): para comparar dos strings lexicográficamente. strlen(): para determinar la longitud de un string. strstr(): para buscar un string en otro.

18 Organización de Computadoras 18 Entrada estándar de strings El modificador %s permite el ingreso de cadenas de caracteres por parte del usuario: char str[25]; scanf( %s, str); // no falta algo?? /* lee hasta encontrar un separador (blancos, fin de líneas, etc.) */ Para leer un string hasta el fin de línea se debe usar el modificador %[^\n] : scanf( %[^\n], str); // lee hasta el '\n'

19 Organización de Computadoras 19 Arreglos y punteros Una variable de tipo arreglo se asimila a un puntero a su primer componente. En consecuencia, puede ser utilizada como tal: int *pb, *pc; int a[5] = {10,20,30,40,50}; pb = a; *pb = 15; pc = &a[3]; *pc += 5; a: pb: pc:

20 Organización de Computadoras 20 Pasaje de arreglos Al pasar un arreglo como argumento, se debe dejar su primera dimensión sin especificar: void times(int vector[], int matrix[][4]) { }... int main() { } int a[12], b[4][4]; times(a, b);

21 Organización de Computadoras 21 Pasaje de arreglos Cabe señalar que, producto de esta omisión, no resulta del todo trivial determinar la longitud de los arreglos recibidos como argumento. Una alternativa relativamente directa consiste en agregar un parámetro adicional que informe el valor de la dimensión faltante. Otra posibilidad es usar alguna variable global para comunicar ese dato. Una tercer propuesta es acordar que el arreglo tenga un tamaño predeterminado, haciendo uso por caso de una constante para denotar ese tamaño.

22 Organización de Computadoras 22 Usando un parámetro extra void mostrar(int vx[], int size) { } int i; for (i = 0; i < size; i++) printf( Elto nro. %i = %i\n, i, vx[i]); int main() { } int a[5] = {10, 20, 30, 40, 50}; mostrar(a,5);

23 Organización de Computadoras 23 Usando una variable global int size = 5; void mostrar(int vx[]) { } int i; for (i = 0, i < size, i++) printf( Elto nro. %i = %i\n, i, vx[i]); int main() { } int a[5] = {10, 20, 30, 40, 50}; mostrar(a);

24 Organización de Computadoras 24 Registros Frecuentemente hace falta manipular múltiples datos de una cierta entidad. Por caso, nombre, apellido y número de registro de un alumno. También, frecuentemente hay que retener datos de múltiple entidades. Qué estructura de datos resulta más conveniente usar? Múltiples arreglos, uno para cada atributo de las entidades?

25 Organización de Computadoras 25 Definición de un registro Los registros son un tipo de dato estructurado compuesto de un conjunto de campos, los que son de otros tipos (básicos o complejos) y que se les asocia una etiqueta a cada uno: struct etiqueta { tipo1 campo1; tipo2 campo2;... } variable1, variable2,...;

26 Organización de Computadoras 26 Definición de un registro struct persona { char nombre[20]; int edad; float altura; } profesor, alumnos[10]; struct persona unprofesor = { Juan Perez, 32, 1.82}; struct persona *palumno;

27 Organización de Computadoras 27 Acceso a los campos Los campos se acceden de dos maneras: Usando el operador punto (.), si es un registro. O bien, usando el operador flecha (->), si se trata de un puntero a un registro. struct persona el, *ella, todos[20]; printf( Nombre: %s\n, el.nombre); todos[2].edad = 20; ella = &todos[2]; printf( Su edad es %d\n, ella->edad);

28 Organización de Computadoras 28 Pasaje de registros En general, ninguna estructura de datos compleja debe ser pasada por valor. La razón es que esto implica el copiado en tiempo de ejecución de mucha información. Por ende, los registros no deben ser pasados como argumentos, al menos no de forma directa. En otras palabras, siempre conviene pasar por valor un puntero a la estructura en cuestión. En todas las arquitecturas, los punteros ocupan apenas unos bytes.

29 Organización de Computadoras 29 Definición de enumerados Los enumerados son conjuntos de constantes numéricas definidas por el usuario. enum colores {rojo, verde, azul}; enum colores fondo, borde = verde; enum booleano { falso = 0, verdadero = 1 }; enum booleano condicion = falso;

30 Organización de Computadoras 30 Definición de tipos de datos Para definir nuevos tipos de datos a partir de otros ya definidos se usa la sentencia typedef: typedef int booleano; typedef struct persona tpersona; typedef struct punto { int coordenadas[3]; enum colores color; } tpunto; tpunto plano[3];

31 Organización de Computadoras 31 Modificadores de variables La declaración de variables acepta los siguientes modificadores: static: el valor de la variable se debe conservar entre las llamadas a la función. register: la variable es almacenada, de ser posible, en un registro del procesador, en vez de hacerlo en memoria principal. volatile: la variable puede ser modificada por un proceso exterior. const: la variable no puede ser modificada, sólo inicializada.

32 Organización de Computadoras 32 Modificadores de variables #include <stdio.h> void count() { } static int acc = 0; printf( %d\n, acc++); int main() { // qué valores se imprimen? } count(); count(); count(); return 0;

33 Organización de Computadoras 33 Modificadores de variables const int max = 10; int letra(const char *text, char l) { int i, acc = 0; for (i=0; i < max && text[i]; i++) if(text[i] == l) acc++; return acc; }

34 Organización de Computadoras 34 Declaraciones constantes Existen dos formas de declarar una variable como constante: const int x = 5; int const x = 5; Pero, al tratarse de punteros no da lo mismo: const char * origen; char * const origen; Consejo práctico: leer la declaración siempre de atrás para adelante!

35 Organización de Computadoras 35 Modificadores de funciones Las funciones también pueden ser declaradas con otros modificadores: static: esta es una restricción de enlace. Denota que sólo se puede usar dentro del archivo de código fuente actual. extern: la variable o función en cuestión será declarada pero no será definida (su definición será provista en otro archivo fuente). inline: la función debe ser expandida íntegramente al ser invocada (es decir, no se va a generar un salto a la función).

36 Organización de Computadoras 36 Modificadores de funciones uno.c static void f() {... } void g() { f(); } dos.c extern void f(); extern void g(); int main() { g(); f(); // Error! }

37 Organización de Computadoras 37 Memoria dinámica La declaración de toda variable reserva un espacio de tamaño previamente conocido en el registro de activación en curso. El espacio reservado para las variables de tipos de dato elementales coincide con lo retornado por la función sizeof(). El espacio reservado para las variables de tipos de dato estructurados coincide con la suma del espacio reservado para cada uno de sus componentes. Por otra parte, también es posible gestionar la reserva y liberación de memoria dinámica.

38 Organización de Computadoras 38 Memoria dinámica C cuenta con las siguientes funciones para la gestionar la asignación de memoria dinámica: void* malloc(size_t): esta función intenta reservar la cantidad indicada de memoria dinámica. free(void*): esta función libera la porción de memoria dinámica que comienza donde se indica. void* realloc(void*, size_t): esta función reajusta al tamaño solicitado el espacio de memoria dinámica que comienza donde se indica.

39 Organización de Computadoras 39 Memoria dinámica Al terminar de hacer uso de grandes estructuras dinámicas enlazadas se debe tener cuidado al liberar el espacio que ocupaban. La invocación a free() sólo libera el espacio reservado por el malloc() que generó el puntero pasado como argumento. Si una estructura se armó mediante múltiples IMPORTANTE! invocaciones a malloc(), su espacio deberá ser retornado mediante múltiples invocaciones a free().

40 Organización de Computadoras 40 int *i; char *c; Memoria dinámica struct persona p; i = (int *) malloc(sizeof(int)); c = (char *) malloc(sizeof(char)); p = (struct persona *) free(i); malloc(sizeof(struct persona)); c = (char *) realloc(c, sizeof(char) * 9);

41 Organización de Computadoras 41 Java vs. C Hasta ahora los lenguajes de programación Java y C han compartido bastantes similitudes, sobre todo a nivel de sintaxis. En este punto aparece una diferencia que estamos obligados a tener siempre en cuenta: Java se hace cargo por completo de la recuperación de la memoria dinámica asignada a un objeto cuyo uso finalizó. C, en contraste, deja esa tarea por completo en manos del programador.

42 Organización de Computadoras 42 Listas Recordemos las principales características de la estructura de datos dinámica lista : Es una estructura de datos dinámica. El espacio ocupado por sus elementos es asignado a medida que se necesite. Cada elemento apunta al siguiente, determinando una relación lineal. Puede ser simple o doblemente enlazada. Permite implementar pilas y colas.

43 Organización de Computadoras 43 struct celda { }; tipo elemento; struct celda *sig; Listas elto sig elto sig elto sig elto sig

44 Organización de Computadoras 44 Listas Recordemos algunas de las particularidades de esta estructura de datos: Los elementos usualmente son todos del mismo tipo. Por lo general, cada celda es creada por separado invocando repetidamente a la función malloc(). Cada celda apunta a la siguiente. La última celda apunta a NULL. La lista completa se representa mediante un puntero al primer elemento.

45 Organización de Computadoras 45 Posición directa vs. indirecta La posición de un elemento denota su ubicación dentro de la lista. Existen principalmente dos variantes para el concepto de posición: Posición directa: la posición se denota mediante un puntero a la celda conteniendo el elemento deseado. Posición indirecta: la posición se denota mediante un puntero a una celda conteniendo un puntero a la celda conteniendo el elemento deseado.

46 Organización de Computadoras 46 Posición directa vs. indirecta Considerando el elemento elto, el puntero pd representa su posición directa y pi su posición indirecta: pd - sig elto sig - sig - sig pi

47 Organización de Computadoras 47 Inserción en listas Veamos cómo agregar una nueva celda *cel a continuación del elemento en la posición *pd (usando el concepto de posición directa): struct celda *cel, *pd; pd 10 sig 20 sig cel 25 sig 30 sig

48 Organización de Computadoras 48 Inserción en listas Veamos cómo agregar una nueva celda *cel antes que el elemento en la posición *pd (usando el concepto de posición directa): struct celda *cel, *pd; cómo hago para acceder a esta celda? pd 10 sig 20 sig cel 15 sig 30 sig

49 Organización de Computadoras 49 Inserción en listas Para agregar un elemento a una lista antes de otro hace falta poder acceder al elemento anterior en la lista. Esto se puede resolver de varias formas, siempre pagando algún costo: Recorriendo la lista desde el principio. Haciendo uso de posición indirecta en vez de directa. Implementando una lista doblemente enlazada. Qué costo pago en cada caso?

50 Organización de Computadoras 50 Fases de la compilación Compilación (traducción): Preprocesado. Generación de código assembler. Generación de código objeto. Enlazado o vinculación: Enlazado con otros archivos objeto. Enlazado con librerías estándar. Generación del ejecutable.

51 Organización de Computadoras 51 Fases de la compilación.c preprocesado generación de.c código assembler.s.exe compilación.o enlazado ensamblado.o.c.c librerías estándares y del usuario.a.a

52 Organización de Computadoras 52 Directrices al preprocesador Las directrices al preprocesador son interpretadas antes de la compilación: #define: define una nueva constante o macro del preprocesador. #include: indica que se debe incluir el contenido de otro archivo en el punto indicado. #ifdef, #ifndef: señala el comienzo de un bloque de preprocesamiento condicionado. #endif: marca el fin de un bloque de preprocesamiento condicionado.

53 Organización de Computadoras 53 Constantes y macros El preprocesador permite asociar valores constantes a ciertos identificadores que serán expandidos antes de la compilación propiamente dicha: #define variable valor-cte Análogamente, las macros son funciones que han de ser expandidas antes de la compilación: #define macro(args,...) def-función

54 Organización de Computadoras 54 Constantes y macros #define PI 3.14 #define CANT 5 #define AREA(rad) PI * rad * rad #define MAX(a, b) (a > b? a : b) int main() { } int i; float vector[cant]; for(i = 0; i < CANT; i++) vector[i] = MAX(i * 5.2, AREA(i));

55 Organización de Computadoras 55 Archivos de encabezamiento Los archivos de encabezamientos incluidos mediante la directiva #include suelen tener la extensión.h. Las funciones declaradas en los archivos de encabezamiento no incluyen sus implementaciones. Las variables que allí aparezcan están declaradas como extern, ya que su definición ha de figurar en otro archivo fuente.

56 Organización de Computadoras 56 Preprocesado condicional Para incluir código cuya compilación dependa de ciertas circunstancias, se puede hacer uso de las siguientes directivas: #ifdef variable <bloque de sentencias> #endif #ifndef variable <bloque de sentencias> #endif

57 Organización de Computadoras 57 Preprocesado condicional #define DEBUG int main() { } int i, acc; for (i = 0; i < 10; i++) acc = i * i - 1; #ifdef DEBUG printf( fin del bucle: %d, acc); #endif

58 Organización de Computadoras 58 Argumentos en línea En C torna simple acceder a los argumentos suministrados en la línea de comandos: void main(int argc, char *argv[]) { } int i; printf( %d argumentos, argc); for (i = 1; i < argc; i++) { } printf( %d: %s\n, i, argv[i]);

59 Organización de Computadoras 59 Argumentos en línea Cabe acotar que la convención es que el primer argumento es el nombre del programa que se está ejecutando. printf( Invocado como: %s,argv[0]); Es decir, los argumentos en las las restantes posiciones (de 1 a argc-1), son los argumentos en la línea de comando efectivos. Nótese que los argumentos se reciben como cadenas de caracteres, incluso al tratarse de números.

60 Organización de Computadoras 60 Gestión de archivos C comparte la filosofía UNIX en el sentido de considerar prácticamente todo como si fuera un archivo: La lectura de información desde un archivo convencional no difiere del ingreso de datos a través del el teclado. La escritura de información hacia un archivo convencional no difiere de la salida de datos por pantalla.

61 Organización de Computadoras 61 Funciones de librería C cuenta con diversas funciones de librería sobre archivos: FILE* fopen(char*, char*): apertura de un archivo para lectura o escritura. int fclose(file*): cierre de un archivo. int fprintf(file*,...): escritura con formato. int fscanf(file*,...): lectura con formato. int feof(file*): determina si se ha alcanzado el final de un archivo.

62 Organización de Computadoras 62 Archivos especiales Todo programa asocia tres constantes de tipo FILE* por defecto a los siguientes archivos: stdin: entrada estándar (descriptor 0). stdout: salida estándar (descriptor 1). stderr: error estándar (descriptor 2). Por caso: fprintf(1, Usuario: ); fscanf(0, %s, usuario); fprintf(stderr, Error: No válido );

63 Organización de Computadoras 63 Conversión de tipos C cuenta con diversas funciones de librería para asistir al programador en la conversión entre tipos de datos: int atoi(char*): traduce de strings a enteros. long atol(char*): traduce de strings a enteros largos. double atof(char*): traduce de strings a reales. char* itoa(char*, int): traduce de enteros a strings.

64 Organización de Computadoras 64 Código enrevezado C, fiel a su filosofía minimalista, permite como válido código un tanto llamativo, a saber: int a[5]; int b = 3; a[1] = 101; // a[1] = 101 2[a] = 102; // a[2] = 102 a[b] = 103; // a[3] = b[a]; // a[3] = 104 (++b)[a] = 104; // a[4] = 104

65 Preguntas? Organización de Computadoras 65