tutorial de code::blocks

1. Como operar con
Code::BLOCK
Primero hay que comenzar con que, es este programa, para que se utiliza y
Quien lo desarrolla.

2. Que es Code::Blocks? 
 Code::Blocks es un IDE libre multiplataforma y de código abierto que soporta
múltiples compiladores, que incluye GCC, Clang y Visual C++. Se desarrolló en
C++ usando wxWidgets como el kit de herramientas GUI. Utilizando una
arquitectura de complemento, sus capacidades y características están
definidas por los complementos proporcionados. A la fecha octubre de 2017,
Code::Blocks está orientado hacia C, C++ y Fortran. Tiene un sistema de
compilación personalizado y un soporte de construcción opcional. Cabe
mencionar que Code::Blocks está licenciado bajo la Licencia pública general
de GNU.

3. Code::blocks 
 Quien lo desarrolla?
 Code::Blocks está siendo
desarrollado
para Windows, Linux y macOS y ha
sido portado a FreeBSD,1 OpenBSD2
y Solaris.3
 Para que se utiliza?
 Debido a que Dev-C++ es un IDE
para los lenguajes C y C++ y está
creado en Delphi, surgió la idea y
necesidad de crear un IDE hecho en
los lenguajes adecuados: C y C++.
Con esta motivación se creó
Code::Blocks.

4. Primeros pasos para utilizar el editor
Code::Blocks
 En esta edición del curso se utilizará un entorno para C llamado Code::Blocks
(de libre distribución). Hay diferentes versiones para usar en distintos
sistemas operativos (Windows, Linux, etc.). Este documento propone una guía
de primeros pasos para empezar a utilizar Code::Blocks.
 1. Obtención e Instalación de Code::Blocks para C
 2. Creación de un Project en Code::Blocks
 3. Creación de un archivo .h en Code::Blocks
 4. Creación de un archivo .cpp en Code::Blocks
 5. Compilación, Linkedición y Ejecución en Code::Blocks
 6. Uso del debugger en Code::Blocks

5. Obtención e Instalación de Code::Blocks
 1. Obtención e Instalación de Code::Blocks para C El instalador puede
obtenerse desde el sitio http://www.codeblocks.org/downloads/binaries.
Desde allí es posible descargar instaladores para distintos sistemas operativos.
Todos los pasos descritos en este documento son válidos para dicha versión. El
instalador correspondiente se llama codeblocks-13.12mingwsetup.exe (97.9
MB). Para este curso, basta con realizar la instalación por defecto que sugiere
el programa instalador al ejecutarlo. Una vez instalado Code::Blocks al abrirlo
vemos la siguiente pantalla:

6. .

7. . 2. Creación de un Project en Code::Blocks
Para crear un project de trabajo en Code::Blocks, elegimos la opción
File -> New -> Project: A

8. A continuación elegimos Console Application y presionamos Go:

9. Nos aparece la primera ventana de un asistente que nos guiará en la construcción
del Project (podemos pedirle que omita dicha primera ventana la siguiente vez
que creemos un Project):

10. Programación II – Instructivo para la instalación y utilización de Code::Blocks
Le indicamos que queremos C++ como lenguaje de programación para el Project(siponemos lenguaje C habrá ciertas
características, tales como el pasaje por referencia,
que quizás no se puedan utilizar correctamente):
CeRP del Suroeste – Programación II :: 2016
 .

11. Programación II – Instructivo para la instalación y utilización de Code::Blocks
Luego le ponemos título (nombre) al Project e indicamos en qué carpeta queremos
guardarlo
 .

12. Ahora debemos indicarle qué compilador de C++ queremos usar en el Project, ya que
podría haber más de uno instalado en nuestra PC. En este curso elegimos GNU
GCC Compiler, que es el compilador que viene junto con el instalador de
Code::Blocks. También le tildamos las opciones Create “Debug” y Create “Release”
configuration:
 .

13. Una vez presionado Finish, nos aparece nuestro Project bajo la pestaña de proyectos.
El Project ya nos incorpora automáticamente el programa main con un código fuente
por defecto.
 .

14. Observación: En Code::Blocks, el programa main habitualmente retorna int en lugar
de void. Podemos cambiar el código fuente por defecto del main por otro escrito por
nosotros:
 .

15. 3. Creación de un archivo .h en Code::Blocks
Una vez creado nuestro Project de trabajo, veremos cómo crear un archivo .h
para un
módulo. Elegimos la opción File New File…:
 .

16. A continuación elegimos C/C++ header y
presionamos Go:
 .

17. Nos aparece la primera ventana de un asistente que nos guiará en la construcción
del archivo .h (podemos pedirle que omita dicha primera ventana la siguiente vez que
creemos un .h):
 .

18. Junto al campo de texto Filename with full path presionamos el botón para elegir
donde guardar nuestro archivo .h. Previamente tildamos las opciones Debug y
Release:
 .

19. Le ponemos un nombre a nuestro archivo .h y lo guardamos en la carpeta
de nuestro
Project:
 .

20. Hecho esto, en el cuadro de texto Header Guard Word nos aparece la palabra que
pondrá automáticamente en las directivas #ifndef y #define del archivo .h Luego
presionamos finish: El archivo .h creado aparece bajo Headers en el Project y nos
despliega el código fuente del archivo, que momentáneamente contiene sólo las
directivas #ifndef, #define y #endif:
 .

21. .
 .

22. Sólo nos resta rellenar el archivo .h con las inclusiones, los tipos de datos y los
cabezales de las operaciones correspondientes al módulo (nótese en el tercer cabezal
de la imagen que bool es un tipo primitivo predefinido en Code::Blocks).
 .

23. 4. Creación de un archivo .cpp en Code::Blocks
Una vez creado el archivo .h para nuestro módulo, veremos cómo crear su
correspondiente archivo .cpp. Elegimos la opción File -> New -> File
.

24. A continuación elegimos C/C++ source y
presionamos Go:
.

25. Nos aparece la primera ventana de un asistente que guiará en la construcción del
archivo .cpp (podemos pedirle que omita dicha primera ventana la siguiente vez
que creemos un .cpp)
.

26. Al igual que como hicimos cuando creamos el Project, le indicamos que queremos
C++ como lenguaje de programación para el archivo .cpp
.

27. Junto al campo de texto Filename with full path presionamos el botón para elegir
donde guardar nuestro archivo .cpp. Previamente tildamos las opciones Debug y
Release
.

28. Le ponemos un nombre a nuestro archivo .cpp y lo guardamos en la carpeta del
Project:
.

29. Hecho esto, nos muestra la ruta completa de donde queda guardado nuestro
archivo .cpp. Luego presionamos finish:
.

30. El archivo .cpp creado aparece bajo Sources en el Project. Sólo nos resta rellenar el
archivo con la inclusión del correspondiente .h y la implementación de las
operaciones pertenecientes al módulo:
.

31. 5. Compilación, Linkedición y Ejecución en Code::Blocks
Una vez creados los archivos .h y .cpp de nuestro Project, veremos cómo compilar,
linkeditar y ejecutar. Para compilar, debemos posicionarnos sobre cada .cpp y
compilarlo por separado(los .h no se compilan). Para ello, elegimos Build Compile
Current File:
.

32. El resultado de la compilación aparece
bajo la pestaña Build Log:
 .

33. Una vez compilados todos los .cpp de nuestro Project (incluido el main),
procedemos a linkeditarlos. Para ello, elegimos Build - Build:
.

34. El resultado de la linkedición aparece bajo la pestaña Build Log. Nos resta
solamente ejecutar el Project, para lo cual elegimos Build -> Run:
.

35. 6. Uso del debugger en Code::Blocks
Veremos cómo usar el debugger en Code::Blocks. Primero elegimos la línea del
programa apartir de donde queremos debuggear. Para ello, elegimos Debug
Toggle Breakpoint:
.

36. Nos aparece una marca roja junto a la línea
de código a partir de donde debuggear:
.

37. Podemos indicar las variables cuyos valores deseamos inspeccionar durante el
debugging. Para ello, elegimos Debug Edit Watches
.

38. Presionamos add e indicamos el nombre de la variable, campo o parámetro cuyo valor
deseamos inspeccionar y presionamos ok:
.

39. La variable agregada nos aparece en Watches. Podemos repetir este proceso
tantas veces como deseemos, con todas las variables, campos o parámetros que
queramos inspeccionar:
.

40. Durante la ejecución con el debugger, si queremos ver cómo cambian los valores de
las variables agregadas, debemos elegir Debug Debugging Windows
Watches:
.

41. Sólo nos resta poner a correr el Debugger. Para ir ejecutando cada instrucción paso a
paso y meternos dentro del código de cada subprograma invocado, elegimos Debug
Step Into. Si queremos pasar directamente a la siguiente línea, elegimos Debug
Next Line
.

42. A medida que ejecutamos paso a paso, vemos cómo cambian los valores de las
variables:
.

43. Para finalizar el debugger, elegimos
Debug Stop Debugger
.

44. Cuando terminamos de trabajar con el Project, lo cerramos
con File Close
Project
.

45. Índice
1Introducción.........................................................................................
...............................................3
2Crear un
proyecto...............................................................................................
................................3
2.1Insertar archivos ya existentes en el
proyecto............................................................................6
2.2Insertar nuevos archivos en el
proyecto......................................................................................7
3Compilando y
ejecutando............................................................................................
.......................8
3.1Depuración........................................................................................
..........................................8
3.1.1Breakpoints.....................................................................................
....................................8

46. 1 Introducción
CodeBlocks es un IDE (Integrated Development Environment, Entorno integrado
de desarrrollo), que permite principalmente el desarrollo en C y C++, si bien
otros lenguajes como Python también están soportados. En este documento se
describe de manera sencilla las operaciones más comunes con el entorno, es
decir: crear un proyecto, compilar, ejecutar y depurar.

47. Figura 1: El IDE Codeblocks
En la figura 1, se aprecia la apariencia del entorno, con la parte derecha
dedicada casi integramente a la edición de archivos (al ser un editor con
pestañas, se pueden editar varios archivos al mismo tiempo). Debajo del edtor,
se encuentra el área de mensajes, donde se obtienen varias informaciones como
por ejemplo los resultados de una búsqueda. Principalmente, también se
mostrarán los resultados de cualquier compilación. En la parte izquierda se
aprecian dos ventanas de depuración: Call stack (la pila de llamadas), y Watches
(visores de variables), que sólo están activas mientras se está depurando un
determinado proyecto. Esta es la configuración por defecto, por lo que la
disposición de las ventanas pueden variar de un usuario a otro.

48. 2 Crear un proyecto
 Para crear un proyecto, se selecciona la opción File >> New, y a continuación,
Project. Para construir el proyecto, básicamente se necesita darle un nombre,
un directorio de residencia, y seleccionar el lenguaje y tipo de aplicación a
desarrollarEn primer lugar, se pregunta el tipo de aplicación a desarrollar,
como se puede ver en la figura 2. El tipo de aplicación más adecuado para
desarrollar aplicaciones en C o C++ estándar es Console Application.

49. Figura 2: Tipos de proyectos
 A continuación, se selecciona el lenguaje de programación a emplear para el
proyecto. Por defecto, seleccionaremos entre C y C++, tal y como se ve en la
figura 3. Una vez seleccionado el lenguaje, será necesario escoger un nombre
para el proyecto, y una ubicación (directorio) en el disco duro.

50. Figura 3: Selección entre lenguajes de
programación disponibles.
 El simple hecho de introducir un título hará que se complementen las
entradas de directorio del proyecto y de nombre del proyecto, tal y como se
ve en la figura 4. A continuación, es necesario seleccionar el compilador a
emplear, además de los perfiles (modos de compilación) a utilizar, como se
aprecia en la figura 5.

51. Figura 4: Título del proyecto.
 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..

52. Figura 5: Perfiles y selección del
compilador.
 El compilador seleccionado es el GNU GCC, que es el que se provee en la
configuración por defecto de CodeBlocks. Si para un proyecto específico se
desea cambiar de compilador, se puede seleccionar ahora. Una vez pulsado
Finish, 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. Para
comprobarlo, sólo es necesario referirse a la ventana Management, y
seleccionar la pestaña Project, como se observa en la figura 6. 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. Si se pulsa el botón derecho del ratón sobre ellos, se
pueden eliminar del proyecto (aunque no son eliminados del disco).

53. 2.1 Insertar archivos ya existentes en el
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 la opción Project >> Add Files, que abre un cuadro de
diálogo de apertura que permitirá seleccionarlos. En la ventana del proyecto
aparecerán correctamente ordenados según sean archivos cabecera (.h) o
archivos de implementación (.c, .cpp). Nótese que, para que una sentencia
como #include “cabecera.h” sea correctamente compilada, también es
necesario añadir al proyecto una indicación de dónde se encuentra ese
archivo de cabecera (si es que no reside en el directorio del proyecto). Esto
se logra en Projects >> Build options, seleccionando entonces la pestaña
Search Directories (figura 7), y pulsando entonces el botón add para añadir un
nuevo directorio. Entonces se escribe la nueva ruta (como se ve en la figura
8), y es añadido a la lista de búsqueda.

54. Figura 7: Añadiendo directorios en las
opciones de construcción del proyecto.
 Una vez hecho ésto, el proyecto se construirá perfectamente. Sólo es
necesario tener en cuenta un detalle: si el camino del directorio a introducir
contiene espacios, es posible que la compilación termine con varios errores
aparentemente inexplicables (como por ejemplo, que no se encuentra
c:documents, en Windows), por lo que si es así, es mucho más conveniente
indicar el nuevo directorio de búsqueda como un camino relativo, en lugar de
absoluto. Así, si necesitamos un

55. Figura 8: Introduciendo el nuevo
directorio de búsqueda.
 directorio llamado Lib que está al mismo nivel que el directorio del proyecto
(como ejemplo, HolaMundo/), entonces será más conveniente fijar el nuevo
directorio de búsqueda como ../Lib. También es posible, en esta ventana,
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.

56. 2.2 Insertar nuevos archivos en el proyecto, Figura 10:
Añadiendo una nueva cabecera al proyecto.
 Es típico que necesitemos incluir nuevos módulos en el proyecto, de manera que dividamos
lafuncionalidad en partes independientes. Lo que desearíamos hacer en ese caso es muy
parecido a lo hecho en el apartado anterior, sólo que ahora los archivos no existen
previamente. Para acceder a esta opción, se selecciona File >> New, y entonces, File. Se nos
da a elegir entre dos opciones: un nuevo archivo de cabecera (header, extensión .h), o de
implementación (source, .c). Se escoja uno u otro, aparece una ventana muy parecida a la
mostrada en la figura 10. En el apartado file name se indica el nombre del archivo, aunque es
necesario tener en cuenta que hay que especificarlo con la ruta completa, por lo que será
mucho más cómodo utilizar el botón a la derecha de este campo, que abre un cuadro de
diálogo de guardado. Si se desea añadir el archivo al proyecto (que es lo más habitual), se
deja marcada la opción Add file to active project. En este caso es necesario añadir el archivo
a los perfiles debug y release. Lo más habitual es asignárselo a ambos, pudiendo hacerlo a
través del botón all o marcando cada uno de ellos. En cuanto al campo header guard word, se
trata de la típica constante utilizada por el preprocesador para hacerle saber si ya ha
compilado esta cabecera previamente para esta unidad de traducción. CodeBlocks rellena
este campo automáticamente, una vez introducido el nombre del archivo, por lo que no es
necesario preocuparse por ello. Finalmente, hay que tener en cuenta que si se ha creado un
archivo de cabecera, y éste se encuentra en un directorio que no es el directorio del
proyecto, será necesario, como se indica en el apartado anterior, añadir la ruta del directorio
en el que se encuentra a las opciones del proyecto.

57. Características
 Code::Blocks es un IDE construido como un núcleo altamente expansible
mediante complementos (plugins). Actualmente la mayor parte de la
funcionalidad viene provista por los complementos incluidos
predeterminadamente. No es un IDE autónomo que acepta complementos,
sino que es un núcleo abstracto donde los complementos se convierten en una
parte vital del sistema. Esto lo convierte en una plataforma muy dinámica y
potente, no solo por la facilidad con que puede incluirse nueva funcionalidad,
sino por la capacidad de poder usarla para construir otras herramientas de
desarrollo tan solo añadiendo complementos.

58. Historia
 Después de liberar dos versiones candidatas para versión final (release
candidate), 1.0rc1 el 25 de julio de 2005 y 1.0rc2 el 25 de octubre de 2005,
en vez de crear una versión final, los desarrolladores del proyecto decidieron
no hacerlo, y comenzaron a añadir algunas características nuevas, con lo que
la liberación de una versión final comenzó a ser repetidamente postpuesta.
Por el contrario, se disponía frecuentemente (casi diariamente) de paquetes
binarios de la última versión del repositorio SVN -llamadas "nightly builds"-,
que los usuarios podían descargar y utilizar. Estas normalmente recibían
mejor soporte que la última versión oficial lanzada, la 1.0rc2. Mientras que
este método proveía a los usuarios de las últimas mejoras del IDE y permitía a
los desarrolladores obtener información constante del funcionamiento, se
creó la falsa ilusión de que el proyecto estaba estancado (debido a que no
salían nuevas versiones oficiales).

59. Edición visual
 Code::Blocks 13.12 incluye wxSmith un complemento que provee la
funcionalidad para la creación y edición visual de una interfaz gráfica de
usuario la cual es una adaptación de wxWidgets basada en la versión 2.9.4.

60. Soporte de compiladores
 Debido a que en sí Code::Blocks es sólo la interfaz del entorno de desarrollo,
puede enlazarse a una variedad de compiladores para poder desarrollar su
trabajo. Por defecto, Code::Blocks buscará una serie de compiladores y
configurará los que halle.