Curso de Lenguaje C

Alexis Olvany torres

Índice Índice..........................................................................................................................3 1. Introducción...........................................................................................................1 2. Estructura de un programa en C.............................................................................1 2.1. Instrucciones para el compilador...............................................................1 2.2. Definición de estructuras...........................................................................2 2.3. Definición de variables..............................................................................2 2.4. Funciones...................................................................................................2 2.5. Programa principal.....................................................................................2 3. Tipos y operadores ................................................................................................3 3.1. Tipos..........................................................................................................3 3.2. Estructuras.................................................................................................4 3.3. Uniones......................................................................................................5 3.4. Enumeraciones ..........................................................................................5 3.5. Modificadores de almacenamiento............................................................6 Modificador "extern"...............................................................................6 Modificador "auto"..................................................................................6 Modificador "register".............................................................................6 Modificador "const"................................................................................6 Modificador "volatile".............................................................................6 Modificador "static"................................................................................7 3.6 Operadores..................................................................................................7 Operadores aritméticos............................................................................7 Operadores de relación y lógicos.............................................................7 Operadores de incremento y decremento................................................8 Operadores para manejo de bits..............................................................8 Operadores de asignación y expresiones.................................................8 Precedencia y asociatividad de operadores.............................................9 Conversión de tipos.................................................................................10 4. Control de flujo......................................................................................................10

4.1. if-else.........................................................................................................11 Expresiones condicionales......................................................................11 4.2. else-if.........................................................................................................12 4.3. switch.........................................................................................................12 4.4. while..........................................................................................................13 4.5. for ..............................................................................................................13 4.6. do-while.....................................................................................................13 4.7. break y continue.........................................................................................14 5. Funciones...............................................................................................................14 6. Apuntadores...........................................................................................................16 7. Compilador cc........................................................................................................17 8. El preprocesador de C............................................................................................18 8.1. Unión de líneas..........................................................................................18 8.2. Definición y expansión de macros.............................................................18 8.3. Inclusión de archivos.................................................................................19 8.4. Compilación condicional...........................................................................19 8.5. Control de línea..........................................................................................20 8.6. Generación de errores................................................................................20 8.7. Pragmas......................................................................................................20 8.8. Directiva nula.............................................................................................20 8.9. Nombres predefinidos................................................................................21 9. Bibliografía.............................................................................................................21 Apéndice A

Compilador XL C................................................................................21

USO:.................................................................................................................21 DESCRIPCIÓN:...............................................................................................22 OPCIONES:......................................................................................................22

1. Introducción El lenguaje C fue hecho por Brian W. Kerninghan y Dennis M. Ritchie a mediados de los 70's, con el objeto de desarrollar el sistema operativo UNIX para la computadora PDP-11. Desde entonces a la fecha ha tenido una amplia aceptación dentro del área de la programación debido a su flexiblidad, tamaño y portabilidad. Es un lenguaje de bajo-medio nivel, que permite el acceso al hardware de la computadora y a su vez el empleo del modelo de programación estructurada, de manera que se puede hacer uso eficiente de los recursos con los que cuenta un equipo de cómputo. El presente curso tiene como objetivo hacer un estudio completo sobre el lenguaje, considerando su sintaxis, estructura y uso de sus instrucciones.

2. Estructura de un programa en C Un programa en C, consta de varias secciones en donde se determinarán que variables y funciones tendrá el programa, así como la tarea que tendrá que realizar. Su estructura está determinada por las partes siguientes: • • • • •

Instrucciones para el compilador Definición de estructuras Definición de variables Funciones Programa principal

2.1. Instrucciones para el compilador Las líneas que se escriben en esta sección indican al compilador la realización de diferentes tareas como: la definición de nombres, tomas de decisión durante la compilación, macros e inclusión de archivos entreotras. Todas las líneas del preprocesador inician con el carácter '#'. Por ejemplo: #include #define PI 3.1416 /* Donde PI es el nombre de la etiquieta y su valor es 3.1416 */

Donde todos los caracteres que se encuentren entre "/*" y "*/", son tomados como comentarios y no tienen efecto para la compilación.

1

2.2. Definición de estructuras En esta área se definen todas las estructuras que requiera el programa. Donde una estructura es la colección de variables para la representación del problema que se está tratando. Por ejemplo: struct esfera { float radio; float volumen; };

2.3. Definición de variables Una vez creados los tipos y estructuras, se procede a la definición de las variables, que son etiquetas con las cuales se tiene acceso a localidades de memoria para el almacenamiento de información durante la ejecución del programa. Un ejemplo definición de variable es: struct esfera A;

2.4. Funciones Las funciones son conjuntos de instrucciones encargadas de la realización de tareas específicas. . Su existencia permite la respresentación del problema en función del modelo de programación estructurada. Una función que calcula el volumen de una esfera se presenta enseguida. void volum(void) { A.volumen= (4.0 / 3.0) * PI * A.radio * A.radio * A.radio; }

2.5. Programa principal El programa principal contiene las instrucciones y llamadas a funciones que se ejecutan en primera instancia. Siempre se tiene el nombre de "main". El programa principal para el cálculo del volumen de una esfera puede ser el siguiente:

void main(void) {

2

printf("\n\t Deme el radio de la esfera: "); scanf("%f",&A.radio); volum(); printf("\n\t El volumen de la esfera con radio %f, es: %f\n",A.radio,\ A.volumen); }

Observación: Es de suma utilidad usar tabuladores para la claridad del programa.

3. Tipos y operadores 3.1. Tipos Las variables usadas en lenguaje C, pueden ser de varios tipos. Éstos, definirán el tamaño en bytes de cada variable. Los tipos que existentes son: void char short int long float double signed unsigned

Sin valor Caracter Entero corto Entero Entero largo Flotante Flotante de doble precisión Usa signo Sin signo

El tipo void permite declarar funciones que no regresan valores y también para la declaración de apuntadores genéricos, es decir capaces de apuntar a cualquier tipo de variable. La declaración de una variable emplea la sintáxis siguiente: Tipo nombre_variable, nombre_variable, nombre_variable = constante;

En la declaración de variables se pueden definir una o más variables del mismo tipo en el mismo renglón, por ejemplo: int numero, altura, profundidad;

Todas las líneas terminan con punto y coma (;). También se les puede asignar un valor inicial en el momento de la definición. Por ejemplo: char letra_inicial = 'J'; float elevacion = 2.43, x = 4.0;

Es importante mencionar que en el nombre de la variable se pueden emplear letras minúsculas, mayúsculas y el carácter '_' (línea de subrayado).

3

También se pueden definir arreglos unidimensionales y multidimensionales. char nombre[30]; unsigned char meses[2][12] = { {31,28,30,31,30,31,30,31,31,30,31,30,31}, {31,28,30,31,30,31,30,31,31,30,31,30,31} };

Las cadenas de caracteres se representan usando doble comilla, por ejemplo: "Es un día soleado", mientras que para un solo carácter se emplea la comilla, por ejemplo: 'a', 'b', 'z'. Las cadenas de caracteres en C, se terminan con el carácter especial '\0'. Otros caracteres especiales (también se les denomina secuencias de escape) son: '\a' '\b' '\f' '\n' '\r' '\t' '\v' '\\' '\?' '\'' '\"' '\ooo' '\xhh' '\0'

carácter de alarma retroceso avance de hoja nueva línea regreso de carro tabulador horizontal tabulador vertical diagonal invertida interrogación apóstrofo comillas número octal número hexadecimal carácter nulo

3.2. Estructuras Una estructura es una colección de variables que se agrupan bajo un una sola referencia. La sintáxis general es: struct nombre_estructura { elemento 1; elemento 2; . . . } variable_struct;

Donde la palabra reservada es "struct", el nombre del conjunto de variables se pone en "nombre_estructura", se abre una llave y enseguida se ponen las variables (cada elemento, usa la declaración de variables usada en el punto 3.1); al terminar de definir todos los elementos, se cierra la estructura con una llave. Hasta aquí, sólo se ha definido la estructura, sin embargo no

4

hay ninguna instancia (creación física) de la misma. Por tanto se hace necesario definir una variable cuyo tipo sea la estructura predefinida. Usemos una estructura ya vista: struct esfera { float radio; float volumen; }; struct esfera A;

Para accesar un campo de la estructura, se usa el nombre de la variable, seguida por un punto y después por el nombre del campo que se va a usar. A.radio = 4.0; A.volumen = 4332.8998;

3.3. Uniones Existe la posibilidad de usar de manera más eficiente la memoria de la computadora, esto se puede lograr empleando la definición de unión. La sintáxis es similar a la de la estructura. union nombre_de_la_union { elemento 1; elemento 2; . . . } variable_union;

La diferencia estriba, en que, en este caso las variables se solapan. Por ejemplo: union libros { char inicial; int num; } lib;

En este caso la unión emplea 2 bytes para la variable "num", y uno de esos bytes se emplea para la variable "inicial", por tanto, no hay 3 bytes en la definición, sino sólo dos.

3.4. Enumeraciones La enumeración es una lista de valores posibles que puede tomar una variable. Por ejemplo: enum ciudades México, Zacatecas, Guanajuato, Nayarit; 5

enum ciudades ciud;

Donde "ciud" sólo puede tomar cualquiera de los nombre dados en la declaración previa.

3.5. Modificadores de almacenamiento Con los modificadores de almacenamiento se altera la forma en que se crea el almacenamiento. Los modificadores son: extern, auto, register, const, volatile y static.

Modificador "extern" Se emplea cuando un programa se encuentra dividido en varios archivos. Como las variables sólo se definen una vez, se hace necesario hacer referencia de ellas en los archivos que así lo requieran. La sintáxis es: extern tipo la_variable; la

/* Se debe indicar también el tipo de variable o función */

Se dice que este tipo de variables tienen "liga externa".

Modificador "auto" Todas las variables son "auto" por omisión, y son objetos locales a un bloque y al salir de éste son descartadas.

Modificador "register" Los objetos declarados como "register" son automáticos y sus valores se almacenan en registros del microprocesador de la computadora.

Modificador "const" Las variables de tipo "const" no pueden cambiarse por el programa durante la ejecución. Una variable "const" recibirá su valor desde una inicialización explícita o por medio de alguna dependencia del hardware.

Modificador "volatile" 6

Las variables modificadas por "volatile" indican que éstas pueden ser modificadas de forma no explícita por el programa. Por ejemplo: se podría guardar la hora exacta en una variable y que la asignación la hiciera la rutina de atención a la interrupción del reloj.

Modificador "static" Se usa para mantener una variable local en existencia durante la ejecución de un programa, de manera que no se tiene que crear y destruir cada vez que se encuentra a la rutina donde está declarada.

3.6 Operadores Los tipos de operadores que existen son: aritméticos, de relación y lógicos, de incremento y decremento, para manejo de bits, de asignación y expresiones, expresiones condicionales.

Operadores aritméticos Los operadores aritméticos binarios son '+', '-', '*', '/' y '%'. Su significado se muestra a continaución: + * / %

Suma de dos operandos Resta entre dos operandos Multiplicación de dos operandos División entre dos operandos Módulo entre dos operandos. Da el residuo de la división resultante entre el operando1 (numerador) y el operando2 (denominador).

La sistáxis es: operando1 operador operando2

La división entera truca cualquier parte fraccionaria.

Operadores de relación y lógicos Los operadores de relación son: '>', ">=", '