PRIMERA CLASE DE C #include <stdio.h> int main() { printf("hola mundo\n"); return 0; } ********************************************************************** Colocar un ejemplo sencillo en C que involucre todo. Estilo pseudocodigo Directivas del preprocesador (Por ahora) Todas las directivas del preprocesador comienzan por el signo # y no terminan en punto y coma (;) ya que no son instrucciones de lenguaje C. #include: Indica al preprocesador que lea el archivo fuente (archivo cabecera o de incusion) que viene a continuacion de ella y su contenido lo inserte en la posicion donde se encuentra dicha directiva. Forma: #include <nombreArch.h> o #include "nombreArch.h" #define: Indica al preprocesador que defina un item de datos u operacion para el programa C: #define PI 3.14 Declaraciones globales: Indica al usuario que las constantes o variables declaradasson comunes a todas las funciones de su probrama, se situan antes de la funcion main. La zona de declararaciones globales puede incluir declaraciones de variables ademas de declaraciones de prototipos de funcion. ********************************************************************** Elementos de un programa en C: - Identificadores: Nombres que se le dan a las constantes o variables (letras, digitos,underscores), el primer caracter debe ser una letra, no puede tener el mismo nombre de las palabras recervadas. - Palabras reservadas: Caracteristica del lenguaje C asociada a algun significado en especial.(void, asm). - Comentarios: Sirven para documentar el compilador los ignora. // Una linea. /* Varias lineas */ - Signos de puntuacion y separadores: Todas las sentencias en C deben terminar con punto y coma (;). Los separadores son espacios en blanco, tabulaciones, retornos de carro y avances de linea. Los signos de puntuacion son: !, %, ... Tipos de datos en C. Los tres tipos de datos basicos son: enteros, numeros de coma flotante (reales) y caracteres. Tipo char short int unsigned int long float double long double Ejemplo 'c' -15 1024 42325 262144 10.5 0.0045 1e-8 Tamaño en bytes 1 2 2 2 4 4 8 8 Rango (minimo-maximo) 0,...,255 -128,...,127 -32768,...,32767 0,...,65535 -2147483628,...,2147483637 3.4E-38,...,3.4E38 1.7E-308,...,1.7E308 igual que el double. Declaracion de variables <tipo_de_dato> <nom_var1>, <nom_var2>,... <nom_varN> *********************************************************************************** Tipos de datos enteros Entero (int) C - permite escribir constantes enteras en difentes bases: decimal: 16 hexadecimal: 0xA (Anteponer 0x al numero en hexadecimal) octal: 020 (Anteponer un signo menos al principio) Exiten tres tipos básicos de enteros: Tipo C int unsigned int short int Rango -32768,...,32767 0,...,65535 -32768,...,32767 Uso Aritmetica de enteros, bucles for, conteo. Conteo, bucles for, indices. Aritmetica de enteros, bucles for, conteo. Tipos de datos enteros largos. long unsigned long -2147483628,...,2147483637 0,...,4294967295 ************************************************************************************ Coma flotante (reales) Tipo C float double long double Rango de valores 3.4E-38,...,3.4E38 1.7E-308,...,1.7E308 3.4E-4932,...,1.1E4932 Precision 7 digitos 15 digitos 19 digitos ************************************************************************************ Caracteres (char) char car = 'b' // Ascii 98 car = car - 32 // Da ya 66 ('B') ************************************************************************************ Tipos de datos logicos Los compiladores en C no incorporan el tipo de dato logico. C usa el tipo int para simular el tipo logico interprestando todo valor diferente de cero como verdadero y el valor de 0 como falso. ************************************************************************************ Constantes Es un objeto cuyo valor no puede cambiar a lo largo de la ejecucion del programa. Tipos: Constantes literales: se clasifican en 4 grupos, asi - Constantes enteras, sucesion de digitos precedidas o no por el signo - o +. - Constantes reales. 82.349, .63, 47e-3, 4.5e+12 - Constantes caracter: 'A','a','1' - Constantes cadena: "Hola mundo". - Constantes definidas (simbolicas). Las constantes pueden recibir nombre simbolicos a traves de la directiva #define. #define nuevaLinea '\n' #define PI 3.1415929 - Constantes numeradas: Permite la creacion de listas de elementos afines. enum dias {lunes, martes,miercoles,jueves,viernes,sabado, domingo}; Empieza en 0 Una vez creado un tipo de datos numerado se pueden declarar variables de ese tipo, como cualquier otro tipo de datos. ************************************************************************************* Constantes declearaso como const y volatile. const: permite dar nombres simbolicos a constantes: tipo nombre = valor; volatile: Actua como const , pero su valor puede ser modificado no solo por el propio programa, tambien por el hardware o software del sistema. *************************************************************************************** Declaracion de variables tipo nombre; tipo nombre = valor; *************************************************************************************** Entradas y salidas Para poder usar funciones de entrada y salida se debe incluir la cabecera stdio.h Salida Con la funcion printf() se visualiza en pantalla los datos del programa, transforma los datos que estan en representacion binaria a codigos ascii asociados, tiene el siguiente formato general. printf(cadena_de_control,dato1,dato2,...) cadena de control: Contiene los tipos de datos y la forma de mostrarlos. dato1,dato2: Variables, constantes, o en general expresiones de salida. Codigos de formato mas usados y su significado. %d El dato se convierte a entero decimal. %o El dato se convierte a entero octal %x El dato se convierte a hexadecimal %u El dato entero se convierte a entero sin signo %c El dato se considera de tipo caracter. %e El dato se considera tipo float o double se convierte a notacion cientifica. %f El dato se considera tipo float o double se convierte a notacion decimal. %g El dato se considera tipo float o double se convierte al codigo %e o %f depenciendo de la representacion mas corta %s El dato ha de ser una cadena de caracteres [...] El item de datos es un string que contiene espacios en blanco. Entrada: La funcion mas utilizada para la entrada de datos es scanf. scanf(cadena_de_control, va1,var2,...,varN) cadena_de_control: Contiene los tipos de datos y si se desea su anchura var1, var2: Variables del tipo de los codigos de control. printf y scanf son funciones mas generales hay funciones mas especificas asociadas solo a cadenas de caracteres. Salida de cadenas de caracteres: Para salida la biblioteca especifica la funcion puts(), tiene un solo argumento que es la cadena de caracteres que se desea que salga en pantalla. Incluye el retorno de carro al final Entrada de cadena de caracteres: Para entrada desde entrada estandar se usa la funcion gets(). Asi gets(variable_cadena) Algunos ejemplos: cadena="Esto es una cadena"; puts(cadena); puts(&cadena[8]); ---------char pax[] = "Juan sin miedo" printf(%s %s\n,pax,&pax[4]); ---------Imprimir la siguiente secuencia *** * * * * ***** * * * * * * ---------float v1,v2; printf("Introduzca v1 y v2"); scanf("%d %f",&v1,v2); Mas sobre la entrada y salida. * Entrada de un unico caracter. Para esto se usa la funcion getchar(). Sintaxis: char variable = getchar() Asi: char z; z = getchar(); // Por ejemplo si meto a por teclado z queda con el valo z='a' Si un end of file (EOD) es encontrado con la funcion getchar entonces el valor de la constante simbolica EOF sera devolvido. Esta en stdio.h y vale -1 tipicamente. Por ejemplo: char z; while (z=getchar())!=EOF) { printf("Todavia no me salgo"); } * Salida de un unico caracter. Sintaxis: putchar(nombre_caracter) char c='5'; putchar(c); * Entrando datos de entrada. (scanf) Ojo recordar que cada nombre de variable debe estar precedido por &. *************************************************************************************** Operadores y expresiones Existen varios tipos de operadores: - Aritméticos, lógicos y relacionales. - De manipulación de bits. - Condicionales. - Especiales. Cuando concurren en una misma expresion diferentes tipos de operadores se dan las reglas de prioridad y asociatividad. Expresion: Sucecion de operadores y operandos debidamente relacionados. --------------------------------------------------------------------------------------Operador de asignacion (=) variable = expresion. Es posible inicializar varias variables con una sola sentencia: a = b = c = 10 Hay cinco operadores de asinacion adicionales proporsionados por c (abreviados) *= /= %= += -= Ejemplo: a*=b ----> a = a*b; -----------------------------------------------------------------------------------------Operadores aritmeticos +, -, *, =, % (En la division si es en entera da el cociente, y el resto da el residuo) Prioridad Prioridad (mayor a menor) +, - (unitario) *,/,% +,- Asociatividad ---> (i-d) ---> (i-d) ---> (i-d) Hacer el ejemplo de la pagina 38 (7*10-5%3+9) Operadores de incrementacion y decrementacion (++ y --) Si se usan como prefijo (predecremento o preincremento): --n, ++n Si se usan como sufijo (postdecremento o post incremento): n--, n++ n-=1 ---- n = n - 1 n=6 m = n++; // m=6 y n quedo en 7, pero se hace primero la asignacion m = ++n; // m=8 ya que n estaba en 7 y se incremeto primero y luego se asigno. z= ++n + 4*n++ - 3; // ? Cual sera la salida --------------------------------------------------------------------------------------Operadores relacionales: Recordar: C no tiene datos de tipo logico. En lugar de esto lo que hace es usar los tipos entero asociando al 0 el falso y a los valores difernetes de 0 el valor de verdadero. Uso de operadores relacionales: <,>,... expresion_1 operador_relacional expresion_2 Operadores relacionales == Igual a != Diferente a > Mayor que < Mayor o igual que >= Menor que <= Mayor o igual que --------------------------------------------------------------------------------------Operadores logicos Se utilizan con expresiones para devolver un valor verdadero o falso. not ! and && or || prioridad (1) (2) (3) La asociatividad va de izquierda a derecha. Evaluacion cortocicuito. --------------------------------------------------------------------------------------Operadores de manipulacion de bits. Los operadores de manipulacion o tratamiento se bits (bitwise) ejecutan operaciones logicas sobre cada uno de los bits de los operandos. Cada operador de manipulacion de bits realiza una operacion logica bit a bit sobre los datos internos. Los operadores de manipulacion de bits solo se aplican a variables o constantes char, int y long. y no a datos de coma flotante. & | ^ xor ~ complemento a 1 (negacion) << Desplazamiento de bits a la izquierda (uso: valor << numero_bits_: n << 1) >> Desplazamiento de bita a la derecha. (uso: valor >> numero_bits_: n >> 3) Mas operadores de asignacion (esta vez usando los operadores de manipulacion de bits) <<= a<<=b Desplaza a a la izquierda b bits y asigna el resultado a a. >>= a>>=b &= a&=b |= a|=b ^= a^=b --------------------------------------------------------------------------------------Operadores de direcciones. Permiten manipular las direcciones de las variables y objetos en general. Operador * corresponde como & ser Accion Lee o modifica el valor apuntado por la expresion. Se un puntero y el resultado es del tipo apuntado. Devuelve un puntero al objeto utilizado como operando, que debe un lvalue (variable dotada de una direccion de memoria). el resultado . estructura). -> apuntado es un puntero de tipo identico al operando. Permite acceder a un miembro de un objeto agrgado (union, Accede a un miembro de un objeto agregado (union, esctructura) por el operando de la izquierda. --------------------------------------------------------------------------------------Operador condicional (Ternario). expresion_C ? expresion_v : expresion_f a<b ? a = 1 : a = 2 c = c>=0 ? 1:-1 --------------------------------------------------------------------------------------Operador coma (,) Permite combinar dos o mas expresiones separadas por coma en una sola linea. expresion1, expresion2,...,expresionN Ej: int i, j, resultado; int i; resultado = j = 10, i = j, ++i; Cual es el valor final de las variables??? --------------------------------------------------------------------------------------- Operadores especiales (), [] Operador (): Es el operador de llamada de funciones. Sirve para encerrar los argumentos de una funcion, efectuar conversiones explicitas de tipo, indicar en el seno de una declaracion que un odentificador corresponde a una funcion, resolver los conflictos de prioridad entre los operadores. Operador []: Sirve para dimensionar los arrays y designar un elemento de un array o una matriz. --------------------------------------------------------------------------------------Operador sizeof Toma como argumento (tipo de dato o nombre de la variable (escalar, array,registro, etc,...)) y obtiene como resultado el numero de bytes que ocupa. El formato del operador es: sizeof(nombre_variable) sizeof(tipo_dato) sizeof(expresion) --------------------------------------------------------------------------------------Conversion de tipos Las conversiones pueden ser implicitas (ejecutadas automaticamente) o explicitas (solicitadas por el programador). Conversion implicita: C hace muchas conversiones implicitas cuando: - Se asigna un valor de una variable de un tipo a una de otro tipo (short c = 9, int a, a = c; sizeof(c)???) - Cuando se convinan tipos mixtos en expresiones (int a =4 ,c ; short b = 3; c=a+b;) - Cuando se pasan argumentos a funciones Los tipos fundamentales (basicos) pueden ser mezclados libremente em asignaciones y expresiones. Las conversiones se ejecutan automaticamente: Los operandos del tipo mas bajo se convierten a los operandos del tipo mas alto de acuerdo con las siguientes reglas: Si cualquier operando es tipo char, short o enumerado se convierte en tipo int; si los operandos tienen los siguientes tipos ver la lista a continuacion, esto se llama promosion integral. int, unsigned int, long, unsigned long, floaf, double.(El tipo que viene primero en la lista se convierte en el segundo...) Conversion explicita C fuerza a conversion explicita mediante el operador molde (cast), que tiene el formato (tiponombre)valor, asi convierte valor a tipo nombre (Ver: short c; (int)c, sizeof(c) ???) --------------------------------------------------------------------------------------Prioridad y asociatividad. Ejemplos revueltos. Entrada de datos mas exactamente: Entrada con letras mayusculas y espacios en blanco. char line[80]; scanf (" %[ ABCDEFGHIJKLMNOPQRSTUWXYZ]",line) Ejemplo ensayar entrando: Santa Marta y SANTA MARTA. Que sucede (printf("%s",line)) A variation of this feature which is often more useful is to precede the characters within the square brackets by a Circumflex (i.e., ^). This causes the subsequent characters within the brackets to be interpreted in the opposite manner. Thus, when the program is executed, successive characters will continue to be read from the standard input device as long as each input character does not match one of the characters enclosed within the brackets. #include <stdio.h> main( ) { char line[80] ; scanf (" %[ "^\n]" , line) ; . . . . . } se sigue la entrada siempre y cuando los caracters no coincidan con los encerrados en [] Mas sobre la funcion scanf: