Proyectos Con CodeBlocks v.1112

EDI Code Blocks
Proyectos -1-
Proyectos
División de un programa en varios módulos.......................................................................................................... 1

Ámbito o alcance...................................................................................................................................................... 4
Ámbito de programa............................................................................................................................................. 4
Especificadores de tipo de almacenamiento........................................................................................................... 4
Variables externas (extern)................................................................................................................................... 5
Creando un Proyecto............................................................................................................................................... 6
Cómo crear un Proyecto en Code Blocks............................................................................................................. 7
Cómo añadir archivos a un Proyecto. ............................................................................................................... 12
Cómo eliminar archivos de un Proyecto. ........................................................................................................... 14
Directorios donde localizar los ficheros de cabecera. ...................................................................................... 15
Cómo cerrar un Proyecto....................................................................................................................................17
Cómo abrir un Proyecto ya existente. ................................................................................................................ 18
Proceso de compilación y linkado de un proyecto................................................................................................ 23
Ubicación de los distintos archivos del proyecto...................................................................................................24
Ejercicios resueltos................................................................................................................................................ 26
METODOS.H......................................................................................................................................................... 28
AUXI.H................................................................................................................................................................... 28
METODOS.C......................................................................................................................................................... 28
AUXI.C................................................................................................................................................................... 28
MEMORIA.H......................................................................................................................................................... 28
MEMORIA.C......................................................................................................................................................... 28
Ejercicios propuestos............................................................................................................................................. 29
CBFAUX.H.............................................................................................................................................................29
CBFAUX.C............................................................................................................................................................. 29
IOVECTOR.H........................................................................................................................................................ 30
VECTOR.H............................................................................................................................................................ 30
IOVECTOR.C........................................................................................................................................................ 30
VECTOR.C............................................................................................................................................................. 30
División de un programa en varios módulos

Hasta ahora, todos los programas que se han expuesto se encontraban en un solo archivo
fuente. Pero los programas grandes son más fáciles de gestionar si se dividen en varios
archivos fuentes, también llamados módulos, cada uno de los cuales puede contener una o
más funciones.
En la práctica, suele dividirse el programa de forma que la función main y las específicas y
particulares del programa se incluyan en un módulo (ó archivo fuente), y el resto de funciones
más generales (que pueden ser válidas para otros programas) se incluyan en otros módulos,
con la facilidad, por consiguiente, de compartir posteriormente este código en otros
desarrollos.
Grado en Ingeniería Informática – Programación II

Departamento de Informática y Automática – Universidad de Salamanca (v.1112)
Profesor: Juan Andrés Hernández Simón
EDI Code Blocks
Proyectos -2-
Los módulos tienen la ventaja de que se pueden desarrollar, compilar, probar y depurar por
separado. Posteriormente con un enlazador (linker) o bien con la herramienta correspondiente
del entorno de desarrollo (el administrador de proyectos, en el caso del EDI de Code
Blocks), se generará un único ejecutable.

EDI Code Blocks
Proyectos -3-
Este proceso se conoce como compilación y enlazado por separado, y constituye el hilo
conductor de la mayoría de los desarrollos.
PROGRAMA
archivos cabecera archivos cabecera archivos cabecera
...
módulo módulo 2 módulo n
principal
PREPROCESADOR PREPROCESADOR PREPROCESADOR
COMPILADOR COMPILADOR COMPILADOR
archivo archivo archivo Módulos de

objeto 1 objeto 2 objeto n biblioteca
ENLAZADOR
Programa ejecutable
Figura 1. Esquema de compilación y enlazado de un programa formado por módulos independientes.
En este tema y siguientes consideraremos archivo fuente y módulo como sinónimos, y

programa será el conjunto de uno o varios archivos fuentes.
Con la compilación por separado, el tiempo de desarrollo de un programa grande se reduce.

Cada módulo puede ser desarrollado, compilado, probado y depurado por programadores
distintos1, solapándose entonces el tiempo de realización y verificación de cada uno de los
1
Este es el caso de grandes programas en los que participa un grupo de programadores y cada uno realiza un
módulo particular.

EDI Code Blocks
Proyectos -4-
módulos.
Igualmente el mantenimiento del software es más sencillo2 y seguro, dado que hacer un
pequeño cambio en un programa exigirá solamente modificar, recompilar y probar el módulo
afectado por la modificación.
Además, en futuros programas pueden reutilizarse estos módulos, con lo que también
disminuiremos tiempos de desarrollos posteriores, al estar utilizando software ya verificado.
Ámbito o alcance
Se conoce como ámbito o alcance de una variable, a la parte de código del programa donde la
variable es conocida3 y por tanto accesible.
Existen cuatro tipos de ámbitos: función, bloque de código, archivo fuente o módulo y
programa. Los tres primeros ya se han explicado en temas anteriores. En el presente
documento nos centraremos en el ámbito de programa.
Ámbito de programa
Las variables que tienen ámbito de programa pueden ser referenciadas por cualquier función
en el programa completo, es decir, desde cualquiera de los módulos que forman el programa.
Tales variables se llaman variables globales al programa.
Para hacer una variable global al programa, debe definirse simplemente al principio de uno de
los fuentes del programa, al principio del mismo y fuera de cualquier función, y
posteriormente declararse dentro de cada uno de los restantes módulos precedida del
especificador de tipo de almacenamiento extern. La cláusula extern se detallará más
adelante.
Especificadores de tipo de almacenamiento

Los especificadores de tipo de almacenamiento permiten modificar el ámbito de una variable
marcado por el lugar de su definición. Son cuatro: auto, static, register y extern.
Los tres primeros ya se han explicado en temas anteriores. En el presente documento nos
centraremos en el especificador de tipo de almacenamiento extern.
2
Es más cómodo editar un archivo fuente pequeño que no de uno con un gran número de líneas.
3
Si una función “reconoce” a una variable, se dice que la variable es “visible” en esa función.

EDI Code Blocks
Proyectos -5-
Variables externas (extern)

A veces se presenta el problema de que una función necesita utilizar una variable que otra
función inicia. Las variables locales no pueden solucionar este problema, ya que sólo son
visibles desde la propia función.
 Si las funciones están definidas en el mismo archivo fuente, bastará definir en el propio
módulo una variable con ámbito de módulo o fuente.
 Si las funciones están definidas en distintos archivos fuentes, en esencia de lo que se trata
es de que una función de un archivo fuente utilice una variable definida en otro archivo
fuente.
La solución es definir la variable con ámbito de módulo en uno de los archivos fuentes
(fuera de cualquier función del mismo), y declararla, en el resto de los archivos
fuentes, con ámbito de módulo, función o bloque, según se necesite, precedida del
especificador de tipo de almacenamiento extern.
Cuando una variable se declara externa, se indica al compilador que el espacio en
memoria para la misma se ha reservado en otro módulo. Posteriormente, cuando los
programas objeto de enlacen, el linker combinará las declaraciones de modo que se
referiran a las mismas posiciones de memoria.
En definitiva, con la cláusula extern podemos conseguir definir variables de ámbito

programa; globales a todo el programa, pues serán visibles desde todos los ficheros
fuentes que formen el programa.
Ejemplo:
Archivo fuente principa.c
#include <stdio.h>
float numf;
int main(void) {
leerReal();
printf("Valor de numero real = %f", numf);
return 0;
}

EDI Code Blocks
Proyectos -6-
Archivo fuente auxiliar.c
#include <stdio.h>
int leerReal(void) {
extern float numf;
printf("Introduzca un valor en coma flotante: ");
scanf("%f", &numf);
return 0;
}
Este ejemplo no tendrá ninguna utilidad especial, ya que su única finalidad es comprobar el
funcionamiento de las variables extern. Es más, se desaconseja el uso de variables extern tal
como entre estos dos módulos se realiza, puesto que no es una buena técnica de programación
utilizar variables globales como medio de comunicación de funciones.
Creando un Proyecto
En el EDI Code Blocks, los programas compuestos de varios archivos fuente se denominan
proyectos. Cada proyecto está asociado a un archivo de proyecto, en el cual se determinarán
cuales son los archivos fuente que forman parte del proyecto. El nombre del proyecto lo
escoge libremente el programador, pero la extensión es fija .cbp.
El menú Proyecto permite gestionar los archivos de un proyecto, tanto los fuente como los
archivos de cabecera (#include).
Figura 2. Menú Proyecto

EDI Code Blocks
Proyectos -7-
Cómo crear un Proyecto en Code Blocks

Para crear un proyecto, básicamente se necesita darle un nombre, un directorio de ubicación
en el ordenador, seleccionar el lenguaje y el tipo de aplicación a desarrollar.
Se describen a continuación la secuencia de ventanas de diálogo en las que debe de
informarse de los anteriores datos.
En primer lugar se acude al menú File y se hace clic en New, y posteriormente en Proyect.
Figura 3. Menú File desde donde crear un proyecto
Aparecerá una ventana de dialogo (figura 4) que nos permitirá elegir entre los distintos tipos
de Proyectos.
Figura 4. Ventana de diálogo para crear un nuevo proyecto

EDI Code Blocks
Proyectos -8-
Seleccionamos el tipo de Proyecto Console Application y pulsando Go pasamos a la siguiente

ventana (figura 5), en la que se selecciona el lenguaje de programación a emplear para el
proyecto. En nuestro caso C, y pulsando Next pasamos a la siguiente ventana (figura 6).
Figura 5. Ventana de diálogo para elegir el lenguaje
Figura 6. Ventana de diálogo para elegir el nombre y ubicación del Proyecto
En esta ventana será necesario escoger un nombre para el proyecto (en el ejemplo
MiProyecto), y una ubicación (directorio) en el disco duro. Para elegir este directorio se
puede acceder a un cuadro de diálogo de navegación, pulsando sobre los tres puntos (…) que
aparecen a la derecha de la segunda línea de entrada de datos.

EDI Code Blocks
Proyectos -9-
El nombre que se le dé al título del proyecto es el que Code Blocks le dará al fichero
ejecutable que generará a partir de la compilación y enlazado de todos los archivos fuentes del
proyecto.
Por defecto será también el nombre del fichero de configuración del proyecto, aunque puede
cambiarse en esta ventana, en la entrada Proyect Filename.
Pulsando Next pasamos a la siguiente ventana (figura 7).
Figura 7. Ventana de diálogo para seleccionar el compilador y los perfiles de compilación
En esta ventana deberá seleccionarse el compilador a emplear, además de los perfiles (modos
de compilación) a utilizar.
Los perfiles por defecto son perfectamente adecuados para cualquier proyecto: debug servirá
para el proceso de desarrollo del software, mientras que release selecciona las opciones del
compilador de mayor optimización y elimina la información de depuración, para el momento
del acabado.

EDI Code Blocks
Proyectos - 10 -
El compilador seleccionado es el GNU GCC, que es el que se provee en la configuración por

defecto de Code Blocks. Si para un proyecto específico se desea cambiar de compilador, se
puede seleccionar ahora.
Una vez pulsado Finish en la anterior ventana (figura 7), el proyecto ha sido creado, así como
el archivo main.c, que aparecerá en el nuevo directorio y como archivo principal de la
compilación.

EDI Code Blocks
Proyectos - 11 -

EDI Code Blocks
Proyectos - 12 -
Para comprobarlo, sólo es necesario referirse a la

ventana Management, y seleccionar la pestaña
Project, como se observa en la figura 8.
Figura 8. Estructura de carpetas y fuentes del

proyecto recién creado
Este archivo maín.c puede utilizarse para

comenzar la codificación en el mismo
desde cero, o bien puede eliminarse del
proyecto, pulsando sobré él con el botón
derecho del ratón y seleccionando Remove
file from proyect (pero no es borrado del
disco).
Figura 9. Como eliminar el archivo main.c del proyecto
Cómo añadir archivos a un Proyecto.

Muchas veces, es necesario incluir archivos ya existentes en un proyecto que acabamos de
crear, típicamente porque estos archivos son
módulos que ya están hechos previamente y
que deseamos aprovechar.
Para añadir estos archivos, se utiliza el menú
Project, y la opción Add Files, la cual abre
un cuadro de diálogo de apertura que

EDI Code Blocks
Proyectos - 13 -
permitirá seleccionarlos. Pueden añadirse múltiples archivos al mismo tiempo,

seleccionándolos todos desde el cuatro de dialogo.
Figura 10. Menú para añadir archivos

a un proyecto ya existente
Una vez seleccionados los archivos deseados, en la ventana del proyecto aparecerán
correctamente ordenados.
Bajo la sección con el nombre del proyecto que se haya

seleccionado, encontraremos dos carpetas: Sources y
Headers. Bajo la primera se encuentran todos los archivos
.c y .cpp, mientras que bajo la segunda se encuentran
todos los archivos .h.
Haciendo doble clic en cualquiera de ellos, hace que
aparezcan en el editor, listo para ser utilizados (figura 12).
Figura 11. Estructura de carpetas y fuentes del proyecto

EDI Code Blocks
Proyectos - 14 -
Figura 12. Solapas de los fuentes del proyecto abiertos simultáneamente
Cómo eliminar archivos de un Proyecto.

Si fuera necesario, hay distintas formas para eliminar archivos de un proyecto. La más
sencilla es pulsar el botón derecho del ratón sobre el nombre del archivo, en el árbol de
directorios del proyecto (pestaña Proyect de la ventana Management), y seleccionar Remove
file from proyect (figura 13). Hay que tener en cuenta que los archivos no son borrados del
disco.
Figura 13. Como eliminar un archivo del proyecto

EDI Code Blocks
Proyectos - 15 -
Directorios donde localizar los ficheros de cabecera.

Nótese que, para que una sentencia como #include “cabecera.h” sea correctamente compilada,
si el archivo cabecera no reside en el directorio del proyecto, es necesario añadir al proyecto
una indicación de dónde debe localizar ese archivo de cabecera Esto se logra en el menú
Projects, opción Build options, seleccionando entonces la pestaña Search Directories
(figura 14).
Figura 14. Ventana de dialogo Proyect build options
Pulsando entonces el botón add para añadir un nuevo directorio. Entonces se escribe la nueva
ruta (como se ve en la figura 15), y es añadido a la lista de búsqueda.
Figura 15. Ventana de dialogo para añadir un directorio

EDI Code Blocks
Proyectos - 16 -
Hay que tener en cuenta un detalle: si el path del directorio a introducir contiene espacios, es
posible que la compilación termine con varios errores aparentemente inexplicables, por lo que
es mucho más conveniente indicar el nuevo directorio de búsqueda como un camino relativo,
en lugar de absoluto. Así, si necesitamos un directorio llamado Lib que está al mismo nivel
que el directorio del proyecto (como ejemplo, MiProyecto), entonces será más conveniente
fijar el nuevo directorio de búsqueda como ..\Lib.
Figura 16. Como indicar un path relativo
También es posible, en esta ventana (figura 14), cambiar el compilador que se ha estado
usando, o las opciones de depuración u optimización, o cualquier otra que se desee añadir.
Nótese que, a la izquierda, aparecen los perfiles que hayamos creado antes (por defecto,
debug y release), de manera que los cambios afectan independientemente a una de los
perfiles: para que afecten a ambos, será necesario repetirlos. Es sencillo comparar ambos
perfiles: el primero tiene todas las opciones de depuración seleccionadas, mientras el otro no
sólo no las tiene, sino que incluye todas las posibles optimizaciones.

EDI Code Blocks
Proyectos - 17 -
Cómo cerrar un Proyecto.

Para cerrar un Proyecto ya existente, se acude al
menú File y se hace clic en Close Proyect.
Figura 17. Menú File desde donde

cerrar un proyecto

EDI Code Blocks
Proyectos - 18 -
Cómo abrir un Proyecto ya existente.

Para abrir un Proyecto ya existente, se acude al menú File y se hace clic en Recent Proyect.
Aparecerá una lista con los últimos proyectos utilizados, y puede elegirse el que se desee.
Figura 18. Menú File para abrir un proyecto reciente
También puede seleccionarse Open…, y aparecerá una ventana de navegación, desde donde
puede buscarse el fichero del proyecto (.cbp), y seleccionarlo para abrirlo.
Figura 19. Ventana de navegación para seleccionar el proyecto

EDI Code Blocks
Proyectos - 19 -
EJEMPLO
Supongamos que queremos crear un proyecto que llamaremos Ordena.cbp el cual va a
contener los archivos TESTORD.C, METODOS.C, MEMORIA.C y AUXI.C. Estos
fuentes ya se encuentran codificados y guardado en un directorio. Además también existen los
archivos de cabecera METODOS.H, MEMORIA.H y AUXI.H.
Podemos seguir los pasos descritos anteriormente hasta conseguir crear un proyecto vacío.
En particular en la ventana de dialogo para elegir el nombre y ubicación de la carpeta del
proyecto, podemos informar lo siguiente (figura 20).
Figura 20. Ventana para indicar el nombre y ubicación del proyecto

EDI Code Blocks
Proyectos - 20 -
El archivo main.c que se genera al crear el proyecto,

lo eliminamos (figura 21). Hay que recordar borrarlo
del directorio (figura 22).
Figura 21. Eliminación del archivo main.c del proyecto
Figura 22. Borrar el archivo main.c del directorio del proyecto
Copiamos en el directorio del proyecto los fuentes ya codificados.

EDI Code Blocks
Proyectos - 21 -
Figura 23. Fuentes en el directorio del proyecto

EDI Code Blocks
Proyectos - 22 -
Añadimos al proyecto los fuentes anteriores (según hemos visto en apartados anteriores.
Así, finalmente tendremos, en la ventana Proyects de la izquierda, el nombre del proyecto (en
nuestro ejemplo Ordena) con la relación de ficheros fuente que incluye. Pulsando sobre cada
uno de ellos, se abrirán los fuentes en distintas ventanas de edición, para poder trabajar con
ellos.
Figura 24. Proyecto y sus distintos fuentes abiertos en el EDI
Si los fuentes hubiera que modificarlos, adaptarlos o terminarlos, se puede hacer

cómodamente activando cada una de las pestañas de cada fuente.

EDI Code Blocks
Proyectos - 23 -
Proceso de compilación y linkado de un proyecto
En el menú Build (figura 25), las opciones Build y Run, construyen (compilan y linkeditan)
y ejecutan el programa, respectivamente.
Se pueden atajar mediante las pulsaciones de teclas Ctrl+F9 y Ctrl+F10 o, incluso, si se
desean realizar ambas acciones en secuencia, seleccionando Build and Run o pulsando F9.
Figura 25. Menú Build
Estas mismas opciones existen en la barra de herramientas. Pulsando la rueda dentada

amarilla se compila (build), y pulsando el triángulo verde de reproducción se ejecuta (run).
El símbolo con la rueda y el triángulo superpuesto (build and run), compila y posteriormente
ejecuta.
El archivo de proyecto .cbp se utiliza para guiar al Code Blocks en la compilación de los
programas fuente. El contenido del archivo .cbp se lee, y se compilan los archivos fuente que
necesiten ser compilados, produciéndose por cada uno de ellos un archivo objeto (.O). A
continuación, se enlazan estos archivos objeto, generándose el ejecutable (.EXE).

EDI Code Blocks
Proyectos - 24 -
Siempre que se compile un proyecto, sólo se compilarán aquellos archivos que realmente sea
necesario. Code Blocks determina esto, comprobando la fecha y hora asociados a cada
archivo fuente (.C) y a su correspondiente archivo objeto (.O). Si el fuente es más moderno
que el objeto, entonces Code Blocks determina que el archivo fuente ha sido modificado, y lo
recompila. En caso contrario, se limita a utilizar el archivo .O.
Lo mismo ocurre con el archivo .EXE. Mientras el archivo .EXE sea más moderno que todos
los archivos .O del proyecto, no se recompilará nada. En caso contrario, se compilan los
archivos necesarios, y se vuelve a enlazar el proyecto.
Además de comprobar las fechas que hay en los archivos .C, .O y .EXE, Code Blocks
comprueba si alguno de los archivos de cabecera (.h) utilizados en el proyecto es más
moderno que alguno de los fuentes que lo utiliza. De ser así, todos los archivos fuentes que lo
utilicen se recompilan automáticamente.
Ubicación de los distintos archivos del proyecto
Si navegamos por la carpeta del proyecto de nuestro ejemplo, podremos observar que los
ficheros objeto, fruto de la compilación, se han creado en el subdirectorio
C:\Temp\Ordena\obj\Debug,
Figura 26. Ubicación de los archivos objeto

EDI Code Blocks
Proyectos - 25 -
y que el ejecutable final se ha creado en el subdirectorio C:\Temp\Ordena\bin\Debug.
Figura 27. Ubicación del ejecutable

EDI Code Blocks
Proyectos - 26 -
Ejercicios resueltos
EJERCICIO 1
Este ejercicios está parcialmente resuelto, paso a paso, en un ejemplo visto anteriormente.
En el ejercicio que se presenta, se utilizarán tres algoritmos básicos de ordenación (burbuja,

inserción y selección) y técnicas de reserva dinámica de memoria. Si estos temas todavía no
han sido presentados en el actual curso, la completa comprensión de este ejercicio puede ser
necesaria posponerla hasta el estudio en profundidad de estos recursos en las próximas
prácticas.
De todas formas, el propósito de este ejercicio resuelto es presentar las técnicas del diseño
distribuido de programas en diversos fuentes, y la compilación por separado utilizando
proyectos, por lo que incluso no conociendo en profundidad todavía los temas antes
indicados, podrá realizarse el ejercicio para conseguir el objetivo señalado.
Se solicita codificar en forma de función, los algoritmos de ordenación básicos.

Se deberán introducir en un fichero fuente independiente, que podremos llamar
METODOS.C para que puedan ser utilizados posteriormente por un programa principal,
codificado en un fichero fuente aparte, el cual llamaremos TESTORD.C
Las funciones con los métodos de ordenación deberán recibir el vector a ordenar (puntero a
entero y su longitud), ordenarán el vector recibido y devolverán como valor de retorno el
tiempo tardado en realizar dicha ordenación.
El programa principal debe ser capaz de medir y presentar en pantalla los tiempos de
ejecución de los diferentes algoritmos para vectores de distintas dimensiones. Para ello el
programa principal solicitará los siguientes datos de entrada:
− Longitud máxima del vector a ordenar (long)
− Número de puntos de muestreo que se presentarán (long)
− Tipo de iniciación del vector:
− (a) ordenada ascendentemente
− (d) ordenada descendentemente
− (otro) cargado con números aleatorios

EDI Code Blocks
Proyectos - 27 -
Por ejemplo, si al programa se le proporcionan los siguientes valores

− Longitud máxima del vector a ordenar: 10000
− Número de puntos de muestreo que se presentarán: 5
− Tipo de iniciación del vector: x
Se deberá llegar a ordenar un vector de 10000 enteros, pero debemos mostrar 5 puntos de
muestreo intermedios, por lo que deberemos presentar el tiempo que cada uno de los
algoritmos tarda en ordenar vectores de 2000, 4000, 6000, 8000 y 10000 enteros.
La tabla que se presentará en pantalla tendrá el siguiente aspecto:
METODOS DE ORDENACION
dim vector ord ini burbuja inserción selección
2000 d 0 0 0
4000 d 0 0 0
6000 d 0 1 0
8000 d 1 2 0
10000 d 2 4 1
La primera columna indicará la longitud de los vectores que se han ordenado, la segunda el
tipo de iniciación del vector y el resto, los tiempos tardados por cada uno de los algoritmos.
El proceso a que se habrá realizado para confeccionar la anterior tabla será el siguiente:
− Reservaremos memoria para un vector de 2000 enteros.
− Iniciamos de forma aleatoria dicho vector y lo ordenamos (el mismo) por cada uno de los
métodos, presentando el tiempo tardado por cada uno de ellos.
− Liberamos esta memoria y reservamos memoria para un vector de 4000 enteros.
− Lo iniciamos con números aleatorios y lo ordenamos (el mismo) por cada uno de los
métodos, presentando el tiempo tardado por cada uno de ellos
− Liberamos dicha memoria.
− Etc.
− Así hasta llegar a ordenar vectores de 10000 enteros.
Es importante que las ejecuciones de los algoritmos se realicen con vectores en las mismas
condiciones de orden/desorden.
Todas las funciones auxiliares para manejar los vectores (iniciación, duplicado para mantener
siempre el original, etc, ...) no se codificarán dentro del fuente del programa principal, sino en
un fichero fuente aparte que podremos llamar AUXI.C
Todas las funciones para la creación y liberación de los vectores utilizando memoria
dinámica, se codificarán en un fichero fuente aparte que podremos llamar MEMORIA.C
De esta forma, nuestro programa estará repartido en cuatro ficheros fuentes, con tres archivos
de cabecera, tal como se muestra en el siguiente esquema.

EDI Code Blocks
Proyectos - 28 -
METODOS.H AUXI.H MEMORIA.H
TESTORD.C METODOS.C AUXI.C MEMORIA.C
Todos los fuentes, ya codificados, y sus archivos de cabecera, se encuentran en ficheros con el
nombre antes indicado.
Deberá crearse en Code Blocks un proyecto y compilarlo para generar un ejecutable que
llamaremos ORDENA.EXE.

EDI Code Blocks
Proyectos - 29 -
Ejercicios propuestos
EJERCICIO 2
Tomando como referencia el fuente COMBINAT.C, dividir el mismo en dos:
 Un primer fuente que llamaremos CBPPAL.C, que incluirá la función main, la

función “módulo principal” y la función “presentación”.
 Un segundo fuente que llamaremos CBFAUX.C, que incluirá las funciones:

 combinatorio
 factorial
Crear además un archivo de cabecera para las funciones incluidas en este fuente.
Mediante la compilación por separado, generar un ejecutable NUMCOMB.EXE producto de

los anteriores fuentes.
CBFAUX.H
CBPPAL.C CBFAUX.C
EJERCICIO 3
Realizar un programa que pida por pantalla dos vectores de la misma dimensión y presente
posteriormente
− El módulo de cada uno de ellos.
− Su vector suma.
− Su producto escalar.
El programa deberá solicitar al usuario, previamente, la dimensión de los vectores con los que
trabajará, validando que ésta no supere el valor 25, el cual se definirá como constante dentro
del programa.

EDI Code Blocks
Proyectos - 30 -
Recordar que dados dos vectores n-dimensionales a = (a1, a2, ..., an) y b = (b1, b2, ..., bn),
entonces:
La estructura del programa debe de ser la siguiente:

 Constará de un fuente que llamaremos CALCVECT, que incluirá la función main, la
función “presentación” y las específicas y particulares del programa.
 Constará de un segundo fuente que llamaremos VECTOR, que incluirá tres funciones
que calcularán:
 El módulo de un vector.
 El vector suma de dos vectores.
 El producto escalar de dos vectores.
 Constará de un tercer fuente que llamaremos IOVECTOR, que incluirá dos funciones
con la siguiente finalidad:
 Solicitar un vector por teclado.
 Presentar un vector por pantalla.
De esta forma, nuestro programa estará repartido en tres ficheros fuentes, con dos archivos de
cabecera, tal como se muestra en el siguiente esquema.
VECTOR.H IOVECTOR.H
CALCVECT.C VECTOR.C IOVECTOR.C
Ayuda: puede tomarse como partida para realizar este ejercicio, el código incluido en el
fuente VCTR.C.


Proyectos Con CodeBlocks v.1112

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Proyectos Con CodeBlocks v.1112

Cargado por

Copyright:

Formatos disponibles

EDI Code Blocks

División de un programa en varios módulos.......................................................................................................... 1

División de un programa en varios módulos

Grado en Ingeniería Informática – Programación II

Grado en Ingeniería Informática – Programación II

PREPROCESADOR PREPROCESADOR PREPROCESADOR

COMPILADOR COMPILADOR COMPILADOR

archivo archivo archivo Módulos de

Figura 1. Esquema de compilación y enlazado de un programa formado por módulos independientes.

En este tema y siguientes consideraremos archivo fuente y módulo como sinónimos, y

Con la compilación por separado, el tiempo de desarrollo de un programa grande se reduce.

Grado en Ingeniería Informática – Programación II

Especificadores de tipo de almacenamiento

Grado en Ingeniería Informática – Programación II

Variables externas (extern)

En definitiva, con la cláusula extern podemos conseguir definir variables de ámbito

Archivo fuente principa.c

Grado en Ingeniería Informática – Programación II

Archivo fuente auxiliar.c

Figura 2. Menú Proyecto

Grado en Ingeniería Informática – Programación II

Cómo crear un Proyecto en Code Blocks

Figura 3. Menú File desde donde crear un proyecto

Figura 4. Ventana de diálogo para crear un nuevo proyecto

Grado en Ingeniería Informática – Programación II

Seleccionamos el tipo de Proyecto Console Application y pulsando Go pasamos a la siguiente

Figura 5. Ventana de diálogo para elegir el lenguaje

Figura 6. Ventana de diálogo para elegir el nombre y ubicación del Proyecto

Grado en Ingeniería Informática – Programación II

Figura 7. Ventana de diálogo para seleccionar el compilador y los perfiles de compilación

Grado en Ingeniería Informática – Programación II

El compilador seleccionado es el GNU GCC, que es el que se provee en la configuración por

Grado en Ingeniería Informática – Programación II

Grado en Ingeniería Informática – Programación II

Para comprobarlo, sólo es necesario referirse a la

Figura 8. Estructura de carpetas y fuentes del

Este archivo maín.c puede utilizarse para

Figura 9. Como eliminar el archivo main.c del proyecto

Cómo añadir archivos a un Proyecto.

Grado en Ingeniería Informática – Programación II

permitirá seleccionarlos. Pueden añadirse múltiples archivos al mismo tiempo,

Figura 10. Menú para añadir archivos

Bajo la sección con el nombre del proyecto que se haya

Figura 11. Estructura de carpetas y fuentes del proyecto

Grado en Ingeniería Informática – Programación II

Figura 12. Solapas de los fuentes del proyecto abiertos simultáneamente

Cómo eliminar archivos de un Proyecto.

Figura 13. Como eliminar un archivo del proyecto

Grado en Ingeniería Informática – Programación II

Directorios donde localizar los ficheros de cabecera.

Figura 14. Ventana de dialogo Proyect build options

Figura 15. Ventana de dialogo para añadir un directorio

Grado en Ingeniería Informática – Programación II

Figura 16. Como indicar un path relativo

Grado en Ingeniería Informática – Programación II

Cómo cerrar un Proyecto.

Figura 17. Menú File desde donde

Grado en Ingeniería Informática – Programación II

Cómo abrir un Proyecto ya existente.

Figura 18. Menú File para abrir un proyecto reciente

Figura 19. Ventana de navegación para seleccionar el proyecto

Grado en Ingeniería Informática – Programación II

Figura 20. Ventana para indicar el nombre y ubicación del proyecto

Grado en Ingeniería Informática – Programación II