1 / 49

El lenguaje C

El lenguaje C. Introducción. Palabras claves. Estructura de un programa. # include <stdio.h> // variables externas a usar int main() { printf(“Hello, world."); return 0; }. Directiva al preprocesador. Estructura de un programa. # include < stdio.h >

ayala
Download Presentation

El lenguaje C

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related