CAPTULO 1 ELEMENTOS BSICOS (del lenguaje C)

1.1. ESTRUCTURA DE UN PROGRAMA La forma general de un programa en lenguaje C, viene dado por la siguiente estructura.
declaraciones globales ; main() { declaracin variables locales ; flujo de sentencias } funcion_1() { declaracin variables locales ; flujo de sentencias } . . funcion_n() { declaracin variables locales ; flujo de sentencias }

Dicha estructura se describe en la Tabla 1.1. Seccin

main() { }

Descripcin Representa el cuerpo principal del programa Rutinas llamadas desde el cuerpo principal del programa. Se han llamado funcin_xx slo como nombre genrico. Pueden tener cualquier nombre que el programador desee asignarle. Grupo de instrucciones escritas en cdigo C. Inicio de un bloque de instrucciones Final de un bloque de instrucciones
Tabla 1.1. Descripcin de la estructura de un programa en C.

funcion_1()...funcion_n()

flujo de sentencias { }

Cada declaracin de variable debe terminar con ; (punto y coma). Cada instrucin del grupo flujo de sentencias debe terminar con ;.

2 Preparado por Juan Ignacio Huircn

Otra forma de escribir el bloque principal:

void main() { ... } int main() { ... return 0; }

1.2. COMENTARIOS

Son elementos del programa que sirven para indicar que es lo que hace determinada funcin o que proceso realiza determinada sentencia. Se utilizan con fines de documentacin. Un comentario se especifica de la siguiente forma:
/* Este es un comentario */

Todo lo que se escriba entre estos dos elementos, es decir: /*......*/ compilador y no formar parte del cdigo ejecutable del programa final. Los comentarios no pueden estar anidados, es decir:
/* /* */ */

ser

ignorado por el

El TurboC puede adaptarse para que esto se pueda realizar. Los comentarios son usados con fines de documentacin y permiten realizar la mantencin del software. Ej 1.1. Ejemplo de comentarios en un programa escrito en lenguaje C.
void main() /* Inicio del programa Principal */ { /* Este es un programa que no tiene instrucciones */

1.3. VARIABLES, TIPOS, DECLARACION Y ASIGNACIN Identificacin de variables

$ $ $ $ $

Se pueden usar cualquier caracter alfanumrico. El tamao del identificador est limitado a 32 caracteres. El primer caracter debe ser una letra o un underscore, pero es recomendable que sea una letra, porque el underscore se utiliza para variables del sistema. Las minsculas y las maysculas producen identificadores distintos. El C tiene palabras claves o reservadas y estas no pueden utilizarse como identificadores (ya sea nombre de variables o nombre de funciones).

Herramientas de Programacin

Ej 1.2. Ejemplos de Identificadores

cuenta_iteraciones cuenta_iteraciones2 funcion_leer

Palabras reservadas del lenguaje C

La siguiente tabla muestra las palabras reservadas del Lenguaje C:
auto break case char continue const asm default do double else extern enum cdecl float for goto if int signed far huge long register return short sizeof void interrupt static struct switch typedef union volatile near unsigned while

pascal

Tabla 1.2. Palabras reservadas del lenguaje C.

El primer grupo corresponde al original propuesto por D. Ritchie, el segundo corresponde al propuesto por el comit ANSI, y el tercer es propio del TURBOC de Borland. Para utilizar una variable primero se debe declarar, en esa declaracin se tiene que especificar su tipo. Tipo
int short long char float double

Descripcin entero entero entero doble precisin caracter real real doble precisin

Tamao (bits)
16 16 32 8 32 64

Valores Lmites
-32768 -32768 -2e9 -128 ###10-37 10+38 ###10-307 10+308 a a a a + 32767 + 32767 +2e9 +127 a ### a ###

Tabla 1.3. Tipos de datos manejados por el lenguaje C.

No siempre el tamao de la variable tipo int es igual al de la variable tipo short, esto va a depender de la implementacin del lenguaje.

Modificadores de Tipo El tipo definido de una variable puede ser cambiado mediante el uso de modificadores, estos son:
signed unsigned

4 Preparado por Juan Ignacio Huircn

El entero por defecto es un nmero que puede tomar valores positivos y negativos, pues utiliza el bit ms significativo como signo, luego al anteponerle el modificador unsigned tomara solo valores positivos o sea utilizar el bit destinado al signo como parte del nmero, luego su rango estar entre 0 y 65535. Lo mismo ocurre al anteponer el modificador unsigned al tipo char, en este caso el rango ir de 0 a 255. Este modificador tambin afecta a las variables tipo long pero no a las variables tipo float.

Modificadores de acceso Estos fueron propuestos por ANSI para controlar la forma en que se acceden o modifican las variables.
const volatile

No pueden ser cambiadas durante la ejecucin. Recibe su valor por inicializacin explcita. El valor puede cambiar por medios no explcitamente especificados por el programa.

Ej 1.3. Declaracin de variables.

int i, j; float r; /* Definicin variables enteras globales */ /* Definicin de real g lobal */

void main() /* Aqui comienza el principal */ { int l, k, n, numero; /* Definicion de enteros locales */ char c, dato; /* Variable tipo caracter local */ unsigned j1; /* entero sin signo (local) */ float numreal; /* En este punto deben ir las instrucciones */ }

Con un solo identificador de tipo se pueden declarar varias variables. El C no conoce el tipo booleano (como el pascal), pero puede simular este tipo dando valores 0 o 1 a una variable entera. El identificador void indica el programa principal no retorna un valor, este puede no ir, depende de la versin del compilador. Inicializacin de variables

El C permite realizar la inicializacin de las variables al momento de ser declaradas. Esto presenta limitaciones en cuanto a matrices y a estructuras. Ej 1.4. Inicializacin de variables.
const k1 4.5 /* Declaracin de una constante = 4.5 */

int i=0, j=1; float r=23.045;

/* Definicion e inicializacion */

Herramientas de Programacin

void main() /* Aqui comienza el principal */ { int l, k, n, numero=2; /* Definicion e inicializacion */ char c=0, dato; /* Variable tipo caracter local */ unsigned m=10; /* entero sin signo (local) */ float numreal=-3.273; int error=-1; /* En este punto deben venir la instrucciones */ }

Las constantes reales se pueden expresar en notacin cientfica, es decir

float num_real=4.5e3; float num_real2=1.16E-9; /* 4.50 .10-3 */ /* 1.16 .10-9 */

Si se quiere inicializar constantes tipo long, se le agrega el sufijo L al nmero.

long dato1=343L; long num_long= 65000L;

Las variables tipo char pueden ser inicializadas ya sea en forma de caracter (entre apostrofes), en formato decimal o hexadecimal. Para formato hexadecimal`se antepone 0x y luego el nmero en hexa.
char c='A'; char cc=0x41; char ccc=65; /* caracter */ /* hexa */ /* Decimal */

Note que las variables estn siendo inicializadas con el mismo valor. Esto se llama independencia de la representacin. Tambin es posible inicializar una variable en octal, para ello debe anteponer un 0 (cero) al nmero. Las variables tipo char, int y long se pueden inicializar en hexadecimal.
int i=0xff50; long j=0xa0a0a0a0; /* i=65360 */ /* j=2694881440 */

Existen caracteres destinados a gestin de pantalla e impresora los cuales se usan entre apostrofes o comillas (si van en cadenas de caracteres). Caracter
\n \t \r \f \b \\

Descripcin Newline Carriage return Backspace Cambio de linea Tabulacin Horizontal Control de carro Form Feed Caracter atras backslash

Tabla 1.4. Caracteres especiales.

6 Preparado por Juan Ignacio Huircn

Asignaciones Consiste en el traspaso de un dato a una variable. Este traspaso puede ser directo o puede realizarse desde otra variable. El signo = representa la operacin de asignacin . Ej 1.5. Asignacin de datos.
void main() { int i, j; float x; char caract; i=1;j=2;x=1.5; caract='A'; }

/* Asignacion de valores */

Las asignaciones se pueden encadenar

i=j=2; /* j toma el valor 2 y luego i el valor de j */

La asignacin de cadenas de caracteres se realiza utilizando funciones especiales de tratamiento de cadenas. 1.4. OPERADORES Operadores Aritmticos Operador
+ * / %

Descripcin Suma Resta Multiplicacin Divisin Resto de la divisin entera, no se aplica a variables float ni double
Tabla 1.5. Operadores aritmticos.

Ej 1.6. Operaciones aritmticas.

void main() { int i=10, j=4, k; float r; k=i + j; r=i; r=i/j; r=(float) i/j; k=i%j; r=2.5; i=5;r=r+i; }

/* /* /* /* /* /*

k=14 r=10.0 r=2.0 r=2.5 k=2 r=7.5

*/ */ */ */ */ */

Herramientas de Programacin

Combinacin de operandos de distinto tipo En una expresin aritmtica se pueden mezclar datos de distinto tipo, el compilador C aplica las siguientes reglas: El compilador aplica asociatividad de izquierda a derecha para operadores con la misma prioridad. Para asegurar la precisin en clculos aritmticos los datos tipo float siempre se convierten a double. Cuando todos los operandos estn a la derecha del simbolo "=" son del mismo tipo, el resultado hereda el tipo. Cuando una expresin aritmtica contenga operandos de distinto tipo el compilador efectua conversiones temporales automticas. Los datos tipo char se convierten a int, por lo que ser correcto escribir i=j+0; El caracter 0se convierte en un valor int, es decir 48 (o 0x30) . Si uno de los operandos es double, los otros se convertirn a double y el resultado ser double. Sino Si uno de los operandos es long con signo, los otros se convertiran en long y el resultado ser otro long con signo. Sino Si uno de los operandos sea unsigned, porque entonces los otros se convertirn en unsigned y el resultado ser unsigned . El programador puede imponer la conversin, esto fijando , entre parntesis, un tipo para la operacin. Es decir:
x=(float) i/j;

Esto obliga al compilador a efectuar la conversin del entero i a real, a partir de este punto, el dividendo es un real, luego todos los dems operandos se convertirn en reales y el resultado ser real. Operadores += -= *= /= En lugar de escribir
i=i+20;

se puede escribir

i+=20;

Esta situacin es vlida para:

i=i+k; i=4*i;

puede escribirse

i+=k; i*=4;

Esto ayuda a que el compilador genere cdigo ms ptimo. Es posible que utilizando este tipo de variable no sea tan significativo el ahorro, pero s cuando se utilizan matrices o punteros.

Operadores Lgicos Son muy utilizados para evaluar condiciones de incio o termino de bucles, condiciones de bifurcacin. En orden decreciente de prioridad tenemos:

8 Preparado por Juan Ignacio Huircn

Operador
> >= = = && ! < != || <=

Descripcin Comprobaciones de mayor y menor que Comprobaciones de igualdad y desigualdad Y y O lgicos Negacin

Tabla 1.6. Operadores lgicos.

El operador ! invierte la condicin Operaciones de tratamiento de bits

Estas operaciones suelen ser ms propias de los lenguajes ensambladores, permiten la manipulacin bit a bit de los datos (desplazamiento a la derecha, a la izquierda, convertir 1 en 0, etc). Estas operaciones no son aplicables a variables float ni a variables double.

Operador
& | ^ << >> ~

Descripcin Y ( a nivel de bits) O (a nivel de bits) OR exclusive Desplazamiento izquierda Desplazamiento derecha Complemento a 1

Tabla 1.7. Operadoresde tratamiento de bits.

El operador & no debe confundirse con && (que efecta el Y lgico).

Ej 1.7. Uso de operadores de bits.

void main() { int k, i=8; int j=10 k= i&j; k=i|j; }

/* En Hexa /* 0000 0000 /* 0000 0000 /* 0000 0000

08 , en binario 0000 0000 0000 1000 0000 1010 */ 0000 1000 = 08 = 8 */ 0000 1010 = 0A=10 */

*/

Herramientas de Programacin

Ej 1.8. Si queremos determinar si el bit menos significativo de un char es 1 se puede utilizar :

#include <stdio.h> void main() { unsigned char dato=253; dato=dato&0x01; if(dato==0x01) printf("EL BIT MENOS SIGNIFICATIVO DE DATO ES UNO.."); else printf("EL BIT MENOS SIGNIFICATIVO DE DATO ES CERO.."); }

Operadores de incremento y decremento La operacin:

i=i+1;

Puede escribirse

i++; ++i;

/* posincremento */ /* preincremento */

En el incremento previo, el valor de la variable se incrementa en 1 antes de realizar cualquier operacin de asignacin. En un incremento a posteriori, se efecta la operacin o asignacin, sin que aparentemente importe la presencia del operador ++. La incrementacin o la decrementacin se efecta despus. Ej 1.9. Supongase dos variables cuyos valores antes de realizar la operacin son : i=3 y j=15 Operacin
i=++j; i=j++; i++; j=++i + 5; j=i++ + 5;

equilave a
j=j+1; i=j; i=j; j=j+1; i=i+1; i+=1;j=i+5; j=i+5; i+=1

resultado
i=16 i=15 i=4 i=4 j=8 y y y y j=16 j=16 j=9 i=4

1.5. PUNTEROS A VARIABLES

Un puntero es una variable que contiene la direccin de memoria de otra variable, en lenguaje C, se indica que una variable es de tipo puntero anteponiendole el * (arterisco) al identificador. Cuando a una variable de tipo puntero se le asigna la direccin de una variable determinada, se dice que "apunta" a dicha variable. El formato general es el siguiente:
tipo_var *nombre_punt;

Ej 1.10. Declaracin de un puntero.

void main() { char *pchar; int *pdato; }

/* "apunta" a una variable de tipo char */ /* pdato "apunta" a una variable de tipo entero */

10 Preparado por Juan Ignacio Huircn

Para realizar la asignacin de la direccin de una variable a un puntero determinado, se debe utilizar el operador &.
void main() { int i, *pint; ... pint=&i; /* pint apunta a i }

*/

Para accesar el valor almacenado por la variable apuntada, se usa el operador *.

void main() { int i, *pint; int j, k; pint=&i; /* pint apunta a i * / i=10; j=*pint; /* j almacena el contenido de la variable apuntada por pint */ k=i; /* k=*pint */ }

Ej 1.11. Utilizacin de un puntero. Supongamos el siguiente programa al cual arbitrariamente se le ha asignado el siguiente mapa de memoria correspondeinte a las variables i, j, p.

void main() { int i, j ,*p; i=10; p=&i; j=*p; }

1000 1002 1004

i j p

Al realizar

i=10;

1000 1002 1004

10

i j p

Al realizar

p=&i; 1000

10

i j

1002 1004 1000

Al realizar

j=*p;

1000 1002 1004

10 10 1000

i j p

Herramientas de Programacin

11

Para realizar operaciones aritmticas sobre punteros, podemos analizar el siguiente programa.
void main() { int i,*p; p=&i; /* p apunta a i */ i=10; p++; /* se incrementa la direccin de la variable apuntada */ ... }

antes de ejecutar p++

1000

10

despus de ejecutar p++

1000

10

1004

1000

1004

1002

El incremento que realiza *p depende del tipo de la variable apuntada. Si p apunta a una variable tipo char, p se incrementa en una localizacin de memoria, esa variable ocupa un byte. Si la variable apuntada es de tipo int, se incrementa en 2 localizaciones de memoria. Si es de tipo float, el incremento es de 4 localizaciones de memoria. Ej 1.11. Operaciones de incremento con punteros.
void main() { int i,*p; p=&i; i=10; (*p)++; ... }

/* p apunta a i /* se incrementa

*/ el contenido de la variable apuntada */

antes de ejecutar (*p)++

1000

10

despus de ejecutar (*p)++

1000

11

1004

1000

1004

1000

12 Preparado por Juan Ignacio Huircn

1.6. FUNCIONES Se pueden diferenciar entre las proporcionadas por el lenguaje C (bibliotecas) y las realizadas por usuario. En general las funciones son rutinas que sirven para descomponer un programa en varios mdulos pequeos. Poseen las siguientes caractersticas: Pueden estar en el mismo mdulo fuente que el programa principal, o puden incluirse o compilarse por separado. Pueden ser llamadas por el programa principal o por otra funcin. Pueden llevar o no llevar argumentos. Pueden devolver o no devolver un valor. Pueden poseer sus propias variables e incluso algunas pueden guardar su valor para las sucesivas veces que sea invocada. Tienen slo un punto de entrada Pueden tener diferentes puntos de salida, ya sea mediante la instruccin return o de forma automtica despus de la ltima instruccin de la funcin. El C no distingue entre procedimiento y funcin (como el Pascal). No permite anidamiento de funciones. Slo se pueden pasar argumentos por valor (?). Una funcin tiene la siguiente estructura:
Especificador_de_tipo declaracin { variables locales instrucciones ... } nombre_funcion(lista_argumentos)

Ej 1.12. El siguiente programa llama a una funcin de suma dos enteros.

int suma(i,j) int i, j; { return(i+j); } int suma(i,j); void main() { int i, j, r; i=j=2; r=suma(i,j); i=suma(3,4); } int suma(i,j) int i, j; { return(i+j); }

void main() { int i, j, r; i=j=2; r=suma(i,j); i=suma(3,4); }

Se debe declarar la funcin antes del main(). La funcin puede escribirse de otra forma:

Herramientas de Programacin int suma(int i, int j) { return(i+j); }

13

Las variables locales en una funcin se "crean", cuando se invoca la funcin, y desaparecen cuando la funcin finaliza (cuando se ejecuta la instruccin return o se ejecuta la ltima instruccin). De esta forma la existencia de la variable local est intimamente ligada a la ejecucin de la funcin. Paso de argumentos por referencia En el caso del paso de argumentos por referencia, si el parmetro transferido a la funcin es alterado al interior de sta, ste tambin se ve alterado al terminar de ejecutarse dicha funcin. Para realizar el paso de argumentos por referencia, el argumento que se pasa es la direccin de memoria donde est el contenido de la variable. Ej 1.14. Paso de argumentos por referencia.
void cuadrado(int *numero); void main() { int num; num =3; cuadrado(&num); } void cuadrado(int *numero) { *numero=(*numero)*(*numero); }

En este caso el valor del cuadrado ser devuelto en la variable num.

Funciones proporcionadas por el lenguaje C

El lenguaje C proporciona una gran cantidad de funciones, para facilitar el acceso para entrada/salida, clculo, manejo de cadenas de caractres, manejo de archivos, funciones grficas, etc.. Esta coleccin de funciones se conoce como biblioteca. Para tener acceso a dichas funciones, el programador debe indicarle al compilador que va hacer uso de ellas. Esto se hace mediante la inclusin de un archivo que contiene los prototipos de las funciones. Todos estos archivos tienen extensin *.h. Se le llama genricamente archivos de cabecera (header files). Algunos de los archivos de cabecera ms comunes (estndar) son:

14 Preparado por Juan Ignacio Huircn

Archivos de cabecera ctype.h float.h math.h stdio.h stdlib.h string.h time.h

Propsito Uso de caractres Aritmtica punto flotante Uso de funciones matemticas E/S estndar Librera Estndar Funciones para manejo de cadenas de caracteres Hora del sistema

Tabla 1.8. Archivos de cabecera.

En TurboC, los archivos de cabecera se incluyen de la siguientes forma:

#include<archivo de cabecera> #include<archivo de cabecera> .... void main() { ... }

Ej 1.15. Si se utilizan funciones para entrada y salida estndar

#include<stdio.h> void main() { printf("HOLA MUNDO\n"); }

Algunas versiones usan: #include "stdio.h" . En TurboC se utiliza esta forma cuando los archivos de cabecera estn en el mismo directorio en el que se encuentra el archivo fuente.

Ej 1.16. Uso de otras funciones.

#include<conio.h> #include<stdio.h> void main() { char carac; carac=getch(); printf("%c ",carac); }

/* Lee una tecla y la guarda en carac */ /* Imprime carac en pantalla */

Herramientas de Programacin

15

Ej 1.17. Uso de funciones matemticas

#include <stdio.h> #include <math.h> void main() { float r; r=cos(2*M_PI); printf("%f", r); }

/* M_PI valor definido de ### */ /* Imprime r con formato */

Las diferentes implementaciones del lenguaje C, entregan a los usuarios librerias adicionales, las que pueden ser accesadas a travs de graphics.h , dos.h, etc. (en el caso de Turbo C de Borland). El archivo de cabecera contiene cdigo fuente, de esta forma puede adems ser visualizado por cualquier editor ASCII.

1.7. ALCANCE Y EXTENSIN DE LAS VARIABLES

Es necesario mencionar que las variables en lenguaje C, pueden "existir" en determinados momentos de la ejecucin del programa, adems, pueden ser vlidas slo en forma local o pueden existir permanentemente durante la ejecucin del programa. Las variables entonces se pueden caracterizar de la siguiente forma:

variable

Descripcin

automtica Las variables locales de un funcin son automaticas por defecto. Slo existen mientras se ejecuta la funcin. Cuando la funcin es llamada, se crean las variables (en la pila) y se destruyen cuando la funcin termina. global externa Se definen fuera de cualquier funcin y se pueden accesar desde todas las funciones del mdulo. Es accesada por una funcin sin que se haya reservado memoria, es decir esta variable se ha definido en otro mdulo compilado por separado. Es una variable local de una funcin, pero su valor se guarda se guarda a lo largo de varias invocaciones al procedimiento. Es una variable que el computador deseara guardar en un registro del microprocesador para mejorar prestaciones.

esttica

registro

Tabla 1.9. Alcance de las variables.

16 Preparado por Juan Ignacio Huircn

Ej 1.18. El siguiente programa permite visualizar los cambios de los contenidos de las variables.
#include <stdio.h> void f1(); int i; void main() { int k; i=3; f1(); f1(); } void f1() { int k =2; static h = 5; printf("i : %d i++;h++; k++; }

/* Variable global */

/* Var. automatica local a main */

//

/* Variable automtica local a f1() */ /* Variable esttica */ k : %d // h : %d \n", i, k, h);

Para Ej 1.18 tenemos que el valor de i puede ser modificado desde cualquier parte del programa, el valor de h, aunque es encuentra en una funcin, al salir de lla se mantiene, finalmente el valor de k que es variable local de f1(), se inicializa con un valor que luego es modificado. Sin embargo al llamar una segunda vez esta funcin se vuelve inicializar.

1.8. COMPILACIN UTILIZANDO MDULOS SEPARADOS El lenguaje C permite trabajar con diferentes mdulos de cdigo fuente, stos pueden ser compilados por separado y luego enlazados para generar un archivo ejecutable. Este modo de trabajo se suele llamar modo proyecto. En este modo, funciones definidas en mdulos diferentes pueden tener acceso a variables que no estn definidas en sus mdulos respectivos. Se deben definir las variables como extern. Ej 1.19. Programa en mdulos separados. /* MODULO 1: m1.C */
#include<stdio.h> #include<conio.h> int suma(int x, int y); int resta(int x, int y); extern int dato; void main() { int i=1,j=0; dato=10; j=suma(i,dato); printf("%s %d","Resultado :",j); getch(); }

/* MODULO 2: m2.C */

int dato; int suma(int x, int y) { return(x+y); } int resta(int x, int y) { return(x-y); }

En esta situacin, slo se destina memoria para la variable dato del mdulo m2.C.

Herramientas de Programacin

17

Ej 1.20. Adicionalmente, el usuario puede definir sus propios archivos de cabecera. Considerando el Ej 1.19 tenemos los siguiente: /* MDULO 1: m1.C */
#include<stdio.h> #include<conio.h> #include "aritme.h" extern int dato; void main() { int i=1,j=0; dato=10; j=suma(i,dato); printf("%s %d","Resultado :",j); getch(); }

/* MDULO 2: m2.c */
int dato; int suma(int x, int y) { return(x+y); } int resta(int x, int y) { return(x-y); }

/* MDULO : aritme.h */
int suma(int x, int y); int resta(int x, int y);

El archivo de cabecera se encuentra en el mismo directorio que el archivo fuente.