PDF de programación - atix06 2008

Dirección y Coordinación General
Esteban Saavedra López ([email protected])

Diseño y Maquetación 
Jenny Saavedra López ([email protected])
Esteban Saavedra López ([email protected])

Herramientas

La edición de esta revista fue realizada de forma integra haciendo uso de Software
Libre



Desde el principio de los tiempos el hombre siempre buscó la igualdad en todo, en
derechos y en obligaciones; lastimosamente en muchos lugares y en varios
aspectos después de tantos años, aún no se han podido sopesar problemas de
desigualdad, pero estamos seguros que más temprano que tarde éstos tendrán un
final feliz.

Hoy en día dentro de una vida llena de actividades sociales, económicas y
académicas, todos luchan por conseguir esa preciada igualdad; muchos estamos
convencidos que una forma de establecer la misma, es la de compartir
conocimiento, ya que el compartir representa articular la enseñanza y el aprendizaje
con un objetivo en particular “El bienestar común”, conocedores que el
conocimiento ha llevado, lleva y llevará a construir un futuro mejor para todos.

Todos somos iguales, un título que refleja de forma clara y concisa lo que todo
hombre , mujer, niño o anciano desea, saber que todos somos iguales; a lo largo de
este tiempo dentro de la Revista Atix, nos hemos dado cuenta que el dar
oportunidad a todos (experimentados y novatos) nos ha permitido contribuir a
fortalecer ese espíritu de igualdad, que tanta falta nos hace a todos los seres en
este mundo. Por todo ésto y por mucho más, instamos a todos a construir entornos
de igualdad , sin discriminar ningún criterio en particular.

En éste quinto número ponderamos la continuidad de varios de nuestros artículos
por parte de sus respectivos autores, por el interés que han cobrado estos en
nuestros lectores quienes fielmente continúan número a número todos nuestros
artículos.

El ser todos iguales, nos llevará a tener y vivir un 

futuro mejor.

Bienvenidos a nuestro sexto número

Esteban Saavedra López
Director y Coordinador General

Utilizando herramientas
de desarrollo C++
en Linux (2da parte)

Desarrollar y construir sistemas en entornos *NIX puede llegar a parecer algo dificultoso
al inicio, sin embargo, con el uso adecuado de las herramientas que proveen los
entornos GNU, ésta se vuelve una tarea sencilla.

embargo, existen aplicaciones como DDD
(Data Display Debugger), que permite hacer
una depuración gráfica, aprovechando todos
los comandos de gdb.

Introducción
En el anterior número vimos la forma de
compilar
manualmente un pequeño
ejecutable de distintas maneras, además de
observar algunos estándares de codificación
utilizados en la mayoría de proyectos escritos
en C/C++, tal como la separación entre
declaración y definición.
En esta ocasión estudiaremos algunas
herramientas de apoyo a la codificación:
El depurador estándar de GNU: GNU
Debugger y la herramienta de automatización
orientada a verificar dependencias: Make

Depuración de programas:
gdb
El depurador de GNU (GNU Debugger : gdb)
es una herramienta estándar de alta
versatilidad escrita por el mismísimo Richard
Stallman para el sistema GNU/Linux. gdb es
una herramienta para línea de comandos, por
tanto no posee un front-end gráfico, sin

Archer, la mascota del proyecto gdb

Este tipo de pez es famoso por cazar
insectos (bugs) desde el agua.

Logo del proyecto DDD(Data Display

Debugger)

programa en

Cargar
memoria
Para probar este depurador vamos a utilizar
el siguiente programa:

programa.cpp
1 int otra_funcion(int w, int u){
2 int ret = w;
3 ret = ret * u;
4 return ret;
5 }
6
7 int funcion(int x){
8 int suma=3;
9 for(int j=0;j<3;j++)
10 suma +=
otra_funcion(suma,x);
11
12 return suma;
13 }
14
15 int main(void){
16 int a,b,c;
17 for(int i=0;i<10;i++){
18 a = i+1;
19 b = a+i;
20 c = funcion(a*b);
21 }
22
23 return 0;
24 }

Por si solo, este programa no muestra
absolutamente nada, sin embargo, los
cambios de variables, los ciclos y las
llamadas a funciones es lo que nos interesa.
Primero debemos crear el ejecutable,
además debemos especificar al compilador
que este debe ser “depurable”. Esto se
consigue añadiendo la opción -g , que
incorpora información extra a los archivos
generados, la cual establece un vínculo entre
el archivo binario producido, los archivos
fuente y sus respectivas líneas de código.

arn@localhost:~$ g++ programa.cpp -o
programa -g

Es el momento de preparar y cargar el
ejecutable en memoria del depurador de la
siguiente manera:
arn@localhost:~$ gdb ./programa
GNU gdb 6.8-debian...
....
(gdb)

La nueva línea de comandos se cambiará a
(gdb) que es donde se escriben las órdenes
de depuración. Si ejecutamos el programa en
este punto, la ejecución llegará al final sin
que saquemos beneficio del depurador,

debemos primero establecer breakpoints o
lugares donde el programa se detendrá para
inspeccionarlo.
Un buen punto para poner un breakpoint es
en el inicio mismo del programa, de esta
forma:
(gdb) break main
Breakpoint 1 at 0x804844b: file
programa.cpp, line 17.

La primera línea de código en ejecutarse
será la número 17, aunque en la línea 16
exista código, ésta únicamente declara
variables, no realiza una acción como tal.
Después de establecer el breakpoint, se
ejecuta el programa con la orden run:

(gdb) run
Starting program: /home/arn/programa
Breakpoint 1, main () at programa.cpp:17
17 for(int i=0;i<10;i++){

gdb muestra el contenido de la línea de
código que está a punto de ejecutarse.
Para hacerlo y saltar a la siguiente utilizamos
la orden next:

(gdb) next
18 a = i+1;
Inspección de variables
En este punto vamos a inspeccionar la
variable que controla el ciclo:
utilizando la orden print

(gdb) (gdb)
$1 = 0

El valor de i en estos momentos es cero.
Ejecutemos las siguientes tres líneas de
código. En vez de next, pulsaremos
simplemente la letra n, una comodidad que
nos proporciona gdb para los comandos en
su forma simplificada:

(gdb) n
19 b = a+i;
(gdb) n
20 c = funcion(a*b);
(gdb) n
17 for(int i=0;i<10;i++){

En este punto las variables a, b y c ya
cambiaron,
podemos
inspeccionarlas, en vez de print, usaremos su
equivalente corto p:

que



así



(gdb) p a
$2 = 1
(gdb) p b
$3 = 1
(gdb) p c
$4 = 24

Lo anterior nos indica que la variable a tiene
el valor de 1, b vale 1 y c vale 24.
Una característica poderosa de gdb es la
capacidad de evaluar expresiones arbitrarias.

(gdb) p a * 2 + 4 - b
$5 = 5

La evaluación de la anterior expresión da
como resultado 5.
También podemos cambiar los valores según
nuestras necesidades, alterando el flujo
normal de la ejecución del programa para
realizar pruebas. Por ejemplo, cambiemos el
valor de i con el comando set variable:

(gdb) p i
$6 = 0
(gdb) set variable i = 6
(gdb) p i
$7 = 6

Antes de cambiar el valor de la variable i , su
valor era cero. Después de hacerlo
comprobamos que ahora vale 6.
La inspección y manipulación de variables
puede ser realizada en cualquier punto de la
depuración con las mismas órdenes ya
mencionadas.

Uso de frames
Hasta este momento, hemos inspeccionado
las variables en un solo contexto (main). Las
variables de este contexto son i , a, b y c, en
la línea 20 se utiliza una llamada a una
función, sin embargo, utilizando la orden
next, simplemente ejecutamos dicha línea de
código y saltamos hacia la siguiente sin
entrar en detalles de lo que contiene la
función, tampoco podemos depurar lo que
hace.
Para hacerlo vamos a utilizar la orden next
hasta llegar a dicha línea 20

(gdb) n
18 a = i+1;
(gdb) n
19 b = a+i;
(gdb) n
20 c = funcion(a*b);

Antes de ingresar a depurar la función,
comprobemos el valor del parámetro a*b que
se le está pasando:

(gdb) p a*b
$8 = 120

También comprobaremos el contexto donde
nos encontramos actualmente (main),
utilizando la orden frame, el cual nos da la
información de la línea de código que está a
punto de ejecutarse, y el contexto :

(gdb) frame
#0 main () at programa.cpp:20
20 c = funcion(a*b);

También podemos ver todas las variables
locales del contexto main utilizando la orden
info locals:

(gdb) info locals
i = 7
a = 8
b = 15
c = 24

Es el momento de utilizar la orden step para

hacer un salto hacia dentro de función:

(gdb) step
funcion (x=120) at programa.cpp:8
8 int suma=3;

Adelantemos unas cuantas líneas de código
(4) con la orden next, y noten que esta vez la
depuración es dentro de la función.

(gdb) n
9 for(int j=0;j<3;j++)
(gdb) n
10 suma += otra_funcion(suma,x);
(gdb) n
9 for(int j=0;j<3;j++)
(gdb) n
10 suma += otra_funcion(suma,x);

Es un buen momento para inspeccionar las
variables locales utilizando info locals:

(gdb) info locals
j = 1
suma = 363

y también para verificar el contexto actual con
frame:

(gdb) frame
#0 funcion (x=120) at programa.cpp:10
10 suma += otra_funcion(suma,x);

Entremos un nivel más adentro en las
llamadas a funciones, esta vez dentro de otra
función, con la orden ste