El lenguaje C

1. El lenguaje C Introducción

2. Palabras claves

3. Estructura de un programa # include <stdio.h> // variables externas a usar int main() { printf(“Hello, world."); return 0; } Directiva al preprocesador

4. Estructura de un programa #include <stdio.h> intmain(){ /* Thisis a commentignoredbythecompiler */ intindex; /*con definicion del lugar de almacenamiento sería: intindex @0x00c1;*/ index = 13; printf("Thevalue of theindexis %d\n", index); index = 27; printf("Thevalue of theindexis %d\n", index); return 0; }

5. Estructura de un programa «grande» • Uso de archivos cabecera (.h) por lo general sólo contienen definiciones de tipos de datos, prototipos de funciones y comandos del preprocesador de C • Uso de varios archivos .c por lo general con un preámbulo consistente de las definiciones de constantes, cabeceras a incluir, definición de tipos de datos, declaración de variables globales y externas (e inicializacion), y una o más funciones

6. Estructura de un programa «grande» • División en directorios Por lo general agrupando los archivos relacionados o bajo cierta lógica • Uso de make y makefile Para una fácil y consistente compilación • Uso de macros en make típicamente usadas para guardar nombres de archivos fuente, nombres de archivos objeto, opciones del compilador o links a bibliotecas

7. Tipos de datos • char (1 byte) • int (2 bytes) • float (4 bytes) • double (8 bytes) • void • short – long – signed - unsigned

8. Constantes • 2323 int • 5656L long • 78.56 float • 89e-2 float • 56.9L double • 033 octal • 0xf1 hexadecimal • 0xFUL unsigned long (15 en decimal)

9. Constantes • ‘n’ caracter • ‘\000’ carácter (representado en octal) • ‘\xhh’ carácter (representado en hexa)

10. Constantes • Enumeración: es una lista de valores enteros constantes. Es una opcion al #define. enum opcion {SI,NO,TALVEZ}; //SI vale 1, NO vale2, y así sucesivamente. enum dia {LUNES=1, MARTES=2, ...DOMINGO=‘F’} dia k; k=LUNES; k=3;

11. Identificadores • El primer carácter debe ser una letra, después puede haber letras, números o guión bajo. • Es sensible a mayúsculas y minúsculas. • Hasta 31 caracteres.

12. Variables • Deben declararse antes de utilizarse y pueden ser: • externas: se definen sólo una vez, fuera de toda función y se declaran extern (implícita o explicitamente) en cada función que las vaya a utilizar, siendo comunes a todas. Son inicializadas a 0 por omisión. • internas (o automáticas): son declaradas dentro de una función y solo existen en ellas. No tienen una inicialización por omisión, quedan indefinidas en su valor inicial si no se las inicializa explícitamente.

13. Variables • Las variables pueden ser: • estáticas: son visibles sólo dentro del archivo fuente (externas) o función (internas) en donde se declaran. Las estáticas internas mantienen su valor en sucesivos llamados a la función. Son inicializadas a 0 por omisión. Se deben inicializar con un valor o una expresión constante. • register: le indica al compilador que la variable será muy usada. El compilador decidirá si será almacenada en un registro. No poseen inicialización por omisión.

14. Calificadores de tipo • Sirven para dar características especiales a los objetos (variables) que están siendo declarados: • const: se puede inicializar, pero después no puede cambiarse el valor • volatile: le indica al complilador que su contenido puede variar mas allá del flujo del programa (no son optimizables)

15. Calificador de tipo volatile int z=8; intmain(){ for (int k=1;k<=100;k++){ printf("Z vale%d\n", z); } } ¿Y si Z cambia su valor por factores externos?

16. Ejemplos const y volatile La comillas dobles definen una cadena constdouble e = 2.7182 constcharmsg [] = “warning:” intstrlen (constchar []); constinthex = 0x80A; /* 2058 en decimal */ constint oct = 012; /* 10 en decimal */ volativeint k=2; volativeunsignedchar puerto1 @0x00000002

17. Arreglos y Cadenas intdigitos [10]; int valores[] = {3,4,5,6,7}; // longitud 5 charpatron [] = “salida”; es equivalente a: charpatron [] = {‘s’, ‘a’, ‘l’, ‘i’, ‘d’, ‘a’, ‘\0’} // longitud 7

18. Operadores aritméticos

19. Acceso a datos y elementos de array

20. Operadores lógicos

21. Operadores lógicos

22. Operadores de bits

23. Sentencias de control • while • do...while • for • if ..else • break • continue • switch

24. Funciones • En general un programa en C son muchas funciones de pequeño tamaño, y no pocas funciones de gran tamaño. • La comunicación entre las funciones es por los argumentos, valores de retorno y a través de variables externas. • Los argumentos son pasados por valor.

25. rótulo opcional Estructuras de datos • struct: Colección de variables de distinto tipo, agrupadas bajo un nombre. En memoria puedo almacenar cualquier variable del tipo struct que se defina

26. Estructuras • Las estructuras se pueden anidar : struct rect { struct point p; struct point z; } ; ... struct rect ventana; ventana.p.x =25;

27. Estructuras y funciones • Las estructuras se puede pasar como argumentos de funciones. structpoint pt = {3,5}; structpoint *pp; pp = &pt; • pasar la estructura completa (pt): voidfuncion( structpointw) • pasar un componente de la estructura (pt.x): voidfuncion( int w) • pasar un puntero a una estructura (pp) voidfuncion( structpoint*w)

28. Arreglos de estructuras structmessage { int emisor; int receptor ; char datos [50]; } structmessagebuffer[50]; buffer[0].emisor=0;

29. Uniones • Es semejante a una estructura, pero los campos que declaramos en una unión ocupan todos la misma posición de memoria. • Solo se puede almacenar un campo por vez. • Cuando se define una unión solo se reserva espacio para almacenar el campo de mayor tamaño. • Permite manejar distintos tipos de datos en una misma área de almacenamiento • El programador es responsable del uso debiendo asignar y recuperar coherentemente.

30. Uniones union ejemplo { int entero; //16 bits charcaracter; //8 bits } mi_var; mi_var. entero =0; // solo se puede incializar mediante el primer miembro mi_var. caracter =‘A’; //(como el carácter ASCII de A es 65, mi_var.enterovale 65, es decir 000000001000001) mi_var. entero= 65; // pero no es seguro que mi_var.caracter sea una ‘A’

31. Puede ser cualquier numero de bits Campo de bits • Es un conjunto de bits adyacentes, agrupados, en una palabra. • Los bits se manipulan según su tipo declarado struct { unsigned int ctrl_compresor :1; unsigned int ctrl_cinta :1; unsigned int ctrl_quemador :1; } control; ... control.ctrl_compresor=1; //enciende el compresor

32. Creación de tipos de datos • La instrucción typedef crea una definicion de un tipo de datos: typedef int Longitud; hace que Longitud sea un sinónimo de int. Luego se puede hacer: Longitud k; lo que declara k del tipo Longitud, con todas sus características.

33. Ejemplos de creación de tipos de datos typedef struct { int coor_x; int coor_y; } Complejo; crea el tipo Complejo que es análogo a la estructura definida en este caso.

34. Ejemplos de creación de tipos de datos typedef unsigned char byte; //crea el tipo byte typedef union { byte Byte; struct { byte b0 :1; byte b1 :1; byte b2 :1; byte b3 :1; } Bits; } Control; //crea el tipo Control luego: Control Z; Z.Byte= 4; Z.Bits.b2=˜Z.Bits.b2;

35. Entrada/Salida • El C no tiene instrucciones específicas para I/O. • Existen un conjunto de funciones para I/O desarrolladas y agrupadas en la biblioteca (library) estándar (ANSI): stdio.h #include <stdio.h> //incluye en el programa todas las funciones de la librería.

36. Salida con formato • intprintf(“Cadena de control”, variables, operaciones, ...); printf(“La salida es %6.1f:”,temp); campo

37. Entrada con formato • int scanf(“Cadena de control”, variable, variable, ...); • La variable o variables que se van a introducir tendrán que ir acompañadas delante del nombre por el signo & (son punteros).

38. Ejemplo E/S #include <stdio.h> main() { int edad; char nombre[20]; printf(“Introduce nombre: \n“); scanf(“%s”, nombre); printf(“Introduce edad: \n”); scanf(“%d”, &edad); printf(“Tu nombre es %s y tienes %d años. \n”, nombre, edad); } debe ser lo suficientemente grande

39. Caracteres de control • d entero decimal • c carácter • s tira de caracteres • f número de punto flotante con notación decimal • e número de punto flotante con notación exponencial • u entero decimal sin signo • o entero octal sin signo • x entero hexadecimal sin signo (minúsculas) • X entero hexadecimal sin signo (mayúsculas) • p puntero

40. Funciones para manejar caracteres • int getchar(void ): captura caracteres uno a uno desde la entrada estándar char variable; variable=getchar();

41. Funciones para manejar caracteres • int putchar(int): imprime caracteres uno a uno en la salida estandar y devuelve el carácter escrito o EOF si hubo error. char variable=‘m’; putchar(variable);

42. Proceso de compilación • La compilación de un programa C se realiza en varias fases que normalmente son automatizadas y ocultadas por los entornos de desarrollo: • Preprocesado: consistente en modificar el código en C según una serie de directivas de preprocesador. simplificando de esta forma el trabajo del compilador. • Compilación: que genera el código objeto a partir del código ya preprocesado. • Enlazado: que une los códigos objeto de los distintos módulos y bibliotecas externas (como las bibliotecas del sistema) para generar el programa ejecutable final.

43. Directivas al preprocesador • Facilidad del lenguaje: • Inclusión de archivos include • Definición de macros define • Operador ## • Inclusion condicional # if !defined ......

44. Directivas al preprocesador • Inclusión de archivos: #include “nombrearchivo” o #include <nombrearchivo> • Incluye el contenido del archivo en donde se encuentra el include • El proceso es recursivo

45. Directivas al preprocesador • Sustitución de macros: #define nombre texto_de_reemplazo • Reemplza nombre por texto_de_reemplazo en todo el codigo subsiguiente • Puede manejar argumentos • La sintaxis debe manejarse con mucho cuidado

46. Directivas al preprocesador • Ejemplo: #define PI 3.1416 #define max(A,B) ((A)>(B)?(A):(B)) Si mas adelante en el código en el código dice: x=max(p+g,PI); Quedará: x=((p+g) > (3.1416) ? (p+g) : (3.1416)); Antes de compilar.

47. Directivas al preprocesador #undef nombre • asegura que nombre no será sustituido ## • Concatena argumentos reales durante la sustitucion Ejemplo: #define unir(inicio,fin) inicio ## fin Hace que: A[unir(zapa,tero)]; Pase a ser: A[zapatero];

48. Directivas al preprocesador • Inclusión condicional: #if MICRO == INTEL #define LIBRERIA “intel.h” #elif MICRO == AMD #define LIBRERÍA “amd.h” #else #define LIBRERÍA ... /*aquí va la definicion de la librería generica*/ ... #endif #include LIBRERIA

49. Directivas al preprocesador • #IFDEF, #IFNDEF • Son If especializados que testean si un nombre está definido #ifndef LIBRERÍA #define LIBRERÍA .... #endif