El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Depuración y Pruebas

Siguiente ►
►

En este módulo, aprenderás sobre las técnicas y herramientas esenciales para depurar y probar tu código en C++. La depuración y las pruebas son componentes críticos del desarrollo de software, ya que aseguran que tu código funcione correctamente y sea robusto frente a errores.

  1. Introducción a la Depuración

¿Qué es la Depuración?

La depuración es el proceso de identificar y corregir errores en el código. Estos errores pueden ser de varios tipos, como errores de sintaxis, errores lógicos o errores en tiempo de ejecución.

Herramientas de Depuración

Las herramientas de depuración te permiten ejecutar tu código paso a paso, inspeccionar variables y evaluar expresiones. Algunas herramientas populares incluyen:

  • GDB (GNU Debugger): Un depurador de código abierto para C y C++.
  • LLDB: Un depurador de código abierto que forma parte del proyecto LLVM.
  • Depuradores integrados en IDEs: Como el depurador de Visual Studio, CLion, Code::Blocks, etc.

Ejemplo Práctico con GDB

A continuación, se muestra un ejemplo de cómo usar GDB para depurar un programa simple en C++.

#include <iostream>

int main() {
    int a = 5;
    int b = 0;
    int c = a / b; // Esto causará un error de división por cero
    std::cout << "Resultado: " << c << std::endl;
    return 0;
}

Para depurar este programa con GDB:

  1. Compila el programa con la opción -g para incluir información de depuración: 
    g++ -g -o programa programa.cpp
  2. Inicia GDB con el ejecutable: 
    gdb ./programa
  3. Dentro de GDB, establece un punto de interrupción en la línea donde ocurre la división: 
    (gdb) break main
  4. Ejecuta el programa: 
    (gdb) run
  5. Usa comandos como next para avanzar línea por línea y print para inspeccionar variables: 
    (gdb) next
(gdb) print a
(gdb) print b

  1. Técnicas de Depuración

Puntos de Interrupción (Breakpoints)

Los puntos de interrupción te permiten pausar la ejecución del programa en una línea específica de código. Esto es útil para inspeccionar el estado del programa en momentos críticos.

Inspección de Variables

Durante la depuración, puedes inspeccionar el valor de las variables para verificar si contienen los valores esperados.

Seguimiento de la Pila de Llamadas (Call Stack)

El seguimiento de la pila de llamadas te permite ver la secuencia de llamadas de funciones que llevaron al punto actual de ejecución. Esto es útil para entender el flujo del programa y localizar el origen de los errores.

  1. Introducción a las Pruebas

¿Qué son las Pruebas?

Las pruebas son el proceso de ejecutar tu código con diferentes entradas para verificar que produce los resultados esperados. Las pruebas pueden ser manuales o automatizadas.

Tipos de Pruebas

  • Pruebas Unitarias: Verifican el funcionamiento de unidades individuales de código, como funciones o clases.
  • Pruebas de Integración: Verifican que diferentes unidades de código funcionen correctamente juntas.
  • Pruebas de Sistema: Verifican el sistema completo para asegurar que cumple con los requisitos.

Herramientas de Pruebas

  • Google Test: Un marco de pruebas unitarias para C++.
  • Catch2: Otro marco de pruebas unitarias para C++.

Ejemplo Práctico con Google Test

A continuación, se muestra un ejemplo de cómo escribir una prueba unitaria usando Google Test.

  1. Instala Google Test siguiendo las instrucciones en su repositorio de GitHub.

  2. Escribe una función simple y su prueba unitaria:

// archivo: funciones.cpp
int suma(int a, int b) {
    return a + b;
}

// archivo: funciones_test.cpp
#include <gtest/gtest.h>
#include "funciones.cpp"

TEST(SumaTest, SumaPositivos) {
    EXPECT_EQ(suma(1, 2), 3);
}

TEST(SumaTest, SumaNegativos) {
    EXPECT_EQ(suma(-1, -2), -3);
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}
  1. Compila y ejecuta las pruebas: 
    g++ -std=c++11 -isystem /path/to/googletest/include -pthread funciones_test.cpp /path/to/googletest/libgtest.a /path/to/googletest/libgtest_main.a -o funciones_test
./funciones_test

  1. Ejercicios Prácticos

Ejercicio 1: Depuración con GDB

  1. Escribe un programa en C++ que contenga un error lógico.
  2. Usa GDB para identificar y corregir el error.

Ejercicio 2: Pruebas Unitarias con Google Test

  1. Escribe una función que calcule el factorial de un número.
  2. Escribe pruebas unitarias para verificar que la función funciona correctamente para varios casos (números positivos, cero, etc.).

Soluciones

Ejercicio 1: Depuración con GDB

#include <iostream>

int main() {
    int x = 10;
    int y = 0;
    int z = x / y; // Error: división por cero
    std::cout << "Resultado: " << z << std::endl;
    return 0;
}

Para depurar:

  1. Compila con -g: g++ -g -o programa programa.cpp
  2. Inicia GDB: gdb ./programa
  3. Establece un punto de interrupción: (gdb) break main
  4. Ejecuta: (gdb) run
  5. Inspecciona variables y corrige el error.

Ejercicio 2: Pruebas Unitarias con Google Test

// archivo: factorial.cpp
int factorial(int n) {
    if (n == 0) return 1;
    return n * factorial(n - 1);
}

// archivo: factorial_test.cpp
#include <gtest/gtest.h>
#include "factorial.cpp"

TEST(FactorialTest, Positivos) {
    EXPECT_EQ(factorial(5), 120);
    EXPECT_EQ(factorial(3), 6);
}

TEST(FactorialTest, Cero) {
    EXPECT_EQ(factorial(0), 1);
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

Compila y ejecuta las pruebas como se indicó anteriormente.

Conclusión

En esta sección, has aprendido sobre las técnicas y herramientas esenciales para depurar y probar tu código en C++. La depuración te ayuda a identificar y corregir errores, mientras que las pruebas aseguran que tu código funcione correctamente. Con estas habilidades, estarás mejor preparado para desarrollar software robusto y confiable.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados