CAPÍTULO 1 ELEMENTOS BÁSICOS (del lenguaje C)

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
<
!=
||
<=
!
Comprobaciones de mayor y menor que
Comprobaciones de igualdad y desigualdad
Y y O lógicos
Negación
Tabla 1.6. Operadores lógicos.
El operador ! invierte la condición
Operaciones de tratamiento de bits
Estas operaciones suelen ser más propias de los lenguajes ensambladores, permiten la manipulación 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
&
|
^
<<
>>
~
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 <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 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<archivo de cabecera>
#include<archivo de cabecera>
....
void main()
{
...
}
Ej 1.15. Si se utilizan funciones para entrada y salida estándar
#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 están 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 Programación
15
Ej 1.17. Uso de funciones matemáticas
#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 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 <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 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<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 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<stdio.h>
#include<conio.h>
#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.