CAPÍTULO 1 ELEMENTOS BÁSICOS (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() { declaración variables locales ; flujo de sentencias } funcion_1() { declaración variables locales ; flujo de sentencias } . . funcion_n() { declaración variables locales ; flujo de sentencias }

Dicha estructura se describe en la Tabla 1.1. Sección main() {

Descripción

}

Representa el cuerpo principal del programa

funcion_1()...funcion_n()

Rutinas llamadas desde el cuerpo principal del programa. Se han llamado función_xx sólo como nombre genérico. Pueden tener cualquier nombre que el programador desee asignarle.

flujo de sentencias

Grupo de instrucciones escritas en código C.

{

Inicio de un bloque de instrucciones

}

Final de un bloque de instrucciones Tabla 1.1. Descripción de la estructura de un programa en C.

Cada declaración de variable debe terminar con ; (punto y coma). Cada instrución del grupo flujo de sentencias debe terminar con ;.

2 Preparado por Juan Ignacio Huircán

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 función o que proceso realiza determinada sentencia. Se utilizan con fines de documentación. 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 código 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 documentación y permiten realizar la mantención 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 ASIGNACIÓN Identificación de variables

$ $ $ $ $

Se pueden usar cualquier caracter alfanumérico. El tamaño 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 minúsculas y las mayúsculas 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 Programación

3

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

default do double else extern enum

asm

cdecl

float for goto if int signed far

huge

long register return short sizeof void

static struct switch typedef union volatile

unsigned while

interrupt

near

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 declaración se tiene que especificar su tipo. Tipo

Descripción

Tamaño (bits)

int short long char float

entero entero entero doble precisión caracter real

16 16 32 8 32

double

real doble precisión

64

Valores Límites -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 tamaño de la variable tipo int es igual al de la variable tipo short, esto va a depender de la implementación 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 Huircán

El entero por defecto es un número que puede tomar valores positivos y negativos, pues utiliza el bit más significativo como signo, luego al anteponerle el modificador unsigned tomara solo valores positivos o sea utilizará el bit destinado al signo como parte del número, 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 también 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

No pueden ser cambiadas durante la ejecución. Recibe su valor por inicialización explícita.

volatile

El valor puede cambiar por medios no explícitamente especificados por el programa.

Ej 1.3. Declaración de variables. int i, j; float r;

/* Definición variables enteras globales */ /* Definición 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 versión del compilador. Inicialización de variables

El C permite realizar la inicialización de las variables al momento de ser declaradas. Esto presenta limitaciones en cuanto a matrices y a estructuras. Ej 1.4. Inicialización de variables. const

k1

4.5

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

/*

Declaración de una constante = 4.5

*/

/* Definicion e inicializacion */

Herramientas de Programación

5

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 notación científica, es decir /* 4.50 .10-3 */ /* 1.16 .10-9 */

float num_real=4.5e3; float num_real2=1.16E-9;

Si se quiere inicializar constantes tipo long, se le agrega el sufijo L al número. 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 número en hexa. char c='A'; char cc=0x41; char ccc=65;

/* caracter */ /* hexa */ /* Decimal */

Note que las variables están siendo inicializadas con el mismo valor. Esto se llama independencia de la representación. También es posible inicializar una variable en octal, para ello debe anteponer un 0 (cero) al número. 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 gestión de pantalla e impresora los cuales se usan entre apostrofes o comillas (si van en cadenas de caracteres). Caracter \n \t \r \f \b \\

Descripción Newline Carriage return Backspace

Cambio de linea Tabulación Horizontal Control de carro Form Feed Caracter atras backslash

Tabla 1.4. Caracteres especiales.

6 Preparado por Juan Ignacio Huircán

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 operación de asignación . Ej 1.5. Asignación 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 asignación de cadenas de caracteres se realiza utilizando funciones especiales de tratamiento de cadenas. 1.4. OPERADORES Operadores Aritméticos Operador

Descripción

+ * / %

Suma Resta Multiplicación División Resto de la división entera, no se aplica a variables float ni double Tabla 1.5. Operadores aritméticos.

Ej 1.6. Operaciones aritméticas. 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 Programación

7

Combinación de operandos de distinto tipo En una expresión aritmética 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 precisión en cálculos aritméticos los datos tipo float siempre se convierten a double. Cuando todos los operandos están a la derecha del simbolo "=" son del mismo tipo, el resultado hereda el tipo. Cuando una expresión aritmética contenga operandos de distinto tipo el compilador efectua conversiones temporales automáticas. • Los datos tipo char se convierten a int, por lo que será correcto escribir i=j+´0´; El caracter ´0´se convierte en un valor int, es decir 48 (o 0x30) . • Si uno de los operandos es double, los otros se convertirán 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 convertirán en unsigned y el resultado será unsigned . El programador puede imponer la conversión, esto fijando , entre paréntesis, un tipo para la operación. Es decir: x=(float) i/j;

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

se puede escribir

i+=20;

puede escribirse

i+=k; i*=4;

Esta situación es válida para: i=i+k; i=4*i;

Esto ayuda a que el compilador genere código más óptimo. Es posible que utilizando este tipo de variable no sea tan significativo el ahorro, pero sí cuando se utilizan matrices o punteros.

Operadores Lógicos Son muy utilizados para evaluar condiciones de incio o termino de bucles, condiciones de bifurcación. En orden decreciente de prioridad tenemos:

8 Preparado por Juan Ignacio Huircán

Operador >

>= = = &&

Descripción

< != ||

~

Descripción 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 efectúa el Y lógico).

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 Programación

9

Ej 1.8. Si queremos determinar si el bit menos significativo de un char es 1 se puede utilizar : #include 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 operación: 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 operación de asignación. En un incremento a posteriori, se efectúa la operación o asignación, sin que aparentemente importe la presencia del operador ++. La incrementación o la decrementación se efectúa después. Ej 1.9. Supongase dos variables cuyos valores antes de realizar la operación son : i=3 y j=15 Operación

equilave a

resultado

i=++j; i=j++; i++; j=++i + 5; j=i++ + 5;

j=j+1; i=j; i=j; j=j+1; i=i+1; i+=1;j=i+5; j=i+5; i+=1

i=16 i=15 i=4 i=4 j=8

y y

j=16 j=16

y y

j=9 i=4

1.5. PUNTEROS A VARIABLES

Un puntero es una variable que contiene la dirección 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 dirección de una variable determinada, se dice que "apunta" a dicha variable. El formato general es el siguiente: tipo_var

*nombre_punt;

Ej 1.10. Declaración 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 Huircán

Para realizar la asignación de la dirección 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. Utilización 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; }

Al realizar

Al realizar

i=10;

j=*p;

1000

10

i

1000

i

1002

j

1004

p

Al realizar

p=&i; 1000

1002

j

1002

1004

p

1004

1000

10

i

1002

10

j

1004

1000

p

10

i j

1000

p

Herramientas de Programación

11

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

antes de ejecutar p++

1000

10

i

1004

1000

p

después de ejecutar p++

1000

10

i

1004

1002

p

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 localización 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)++; ... }

antes de ejecutar (*p)++

/* p apunta a i /* se incrementa

1000

10

i

1004

1000

p

*/ el contenido de la variable apuntada */

después de ejecutar (*p)++

1000

11

i

1004

1000

p

12 Preparado por Juan Ignacio Huircán

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 módulos pequeños. Poseen las siguientes características: • Pueden estar en el mismo módulo fuente que el programa principal, o puden incluirse o compilarse por separado. • Pueden ser llamadas por el programa principal o por otra función. • 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 sólo un punto de entrada • Pueden tener diferentes puntos de salida, ya sea mediante la instrucción return o de forma automática después de la última instrucción de la función. • El C no distingue entre procedimiento y función (como el Pascal). • No permite anidamiento de funciones. • Sólo se pueden pasar argumentos por valor (?). Una función tiene la siguiente estructura: Especificador_de_tipo declaración { variables locales instrucciones ... }

nombre_funcion(lista_argumentos)

Ej 1.12. El siguiente programa llama a una función de suma dos enteros. 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); }

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); }

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

Herramientas de Programación

13 int suma(int i, int j) { return(i+j); }

Las variables locales en una función se "crean", cuando se invoca la función, y desaparecen cuando la función finaliza (cuando se ejecuta la instrucción return o se ejecuta la última instrucción). De esta forma la existencia de la variable local está intimamente ligada a la ejecución de la función. Paso de argumentos por referencia En el caso del paso de argumentos por referencia, si el parámetro transferido a la función es alterado al interior de ésta, éste también se ve alterado al terminar de ejecutarse dicha función. Para realizar el paso de argumentos por referencia, el argumento que se pasa es la dirección 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, cálculo, manejo de cadenas de caractéres, manejo de archivos, funciones gráficas, etc.. Esta colección 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 inclusión de un archivo que contiene los prototipos de las funciones. Todos estos archivos tienen extensión *.h. Se le llama genéricamente archivos de cabecera (header files). Algunos de los archivos de cabecera más comunes (estándar) son:

14 Preparado por Juan Ignacio Huircán

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

Propósito Uso de caractéres Aritmética punto flotante Uso de funciones matemáticas E/S estándar Librería Estándar 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 #include .... void main() { ... }

Ej 1.15. Si se utilizan funciones para entrada y salida estándar #include void main() { printf("HOLA MUNDO\n"); }

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

Ej 1.16. Uso de otras funciones. #include #include void main() { char carac; carac=getch(); printf("%c ",carac); }

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

Herramientas de Programación

15

Ej 1.17. Uso de funciones matemáticas #include #include 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 través de graphics.h , dos.h, etc. (en el caso de Turbo C de Borland). El archivo de cabecera contiene código fuente, de esta forma puede además ser visualizado por cualquier editor ASCII.

1.7. ALCANCE Y EXTENSIÓN DE LAS VARIABLES

Es necesario mencionar que las variables en lenguaje C, pueden "existir" en determinados momentos de la ejecución del programa, además, pueden ser válidas sólo en forma local o pueden existir permanentemente durante la ejecución del programa. Las variables entonces se pueden caracterizar de la siguiente forma:

variable

Descripción

automática Las variables locales de un función son automaticas por defecto. Sólo existen mientras se ejecuta la función. Cuando la función es llamada, se crean las variables (en la pila) y se destruyen cuando la función termina. global

Se definen fuera de cualquier función y se pueden accesar desde todas las funciones del módulo.

externa

Es accesada por una función sin que se haya reservado memoria, es decir esta variable se ha definido en otro módulo compilado por separado.

estática

Es una variable local de una función, pero su valor se guarda se guarda a lo largo de varias invocaciones al procedimiento.

registro

Es una variable que el computador desearía guardar en un registro del microprocesador para mejorar prestaciones.

Tabla 1.9. Alcance de las variables.

16 Preparado por Juan Ignacio Huircán

Ej 1.18. El siguiente programa permite visualizar los cambios de los contenidos de las variables. #include 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 automática local a f1() */ /* Variable estática */ 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 función, 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 función se vuelve inicializar.

1.8. COMPILACIÓN UTILIZANDO MÓDULOS SEPARADOS El lenguaje C permite trabajar con diferentes módulos de código 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 módulos diferentes pueden tener acceso a variables que no están definidas en sus módulos respectivos. Se deben definir las variables como extern. Ej 1.19. Programa en módulos separados. /* MODULO 1: m1.C */ #include #include 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 situación, sólo se destina memoria para la variable dato del módulo m2.C.

Herramientas de Programación

17

Ej 1.20. Adicionalmente, el usuario puede definir sus propios archivos de cabecera. Considerando el Ej 1.19 tenemos los siguiente: /* MÓDULO 1: m1.C */

/* MÓDULO 2: m2.c */

#include #include #include "aritme.h"

int dato;

extern int dato; void main() { int i=1,j=0; dato=10; j=suma(i,dato); printf("%s %d","Resultado :",j); getch(); }

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

/* MÓDULO : 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.