C++ 测试与调试：确保代码质量与稳定性

Catch2 框架

Catch2 是另一个流行的选择，语法更简洁，功能也很丰富。

安装指南

# Ubuntu/Debian
sudo apt-get install catch2

# macOS (Homebrew)
brew install catch2

示例代码

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include "MyClass.h"

// 测试 MyClass 的构造函数
TEST_CASE("MyClass Constructor Test", "[constructor]") {
    MyClass obj;
    REQUIRE(obj.getValue() == 0);
}

// 测试 setValue 和 getValue 方法
TEST_CASE("MyClass Set and Get Value Test", "[setget]") {
    MyClass obj;
    obj.setValue(42);
    REQUIRE(obj.getValue() == 42);
}

// 测试 add 方法
TEST_CASE("MyClass Add Test", "[add]") {
    MyClass obj;
    obj.setValue(10);
    int result = obj.add(20);
    REQUIRE(result == 30);
    REQUIRE(obj.getValue() == 30);
}

// 测试 subtract 方法
TEST_CASE("MyClass Subtract Test", "[subtract]") {
    MyClass obj;
    obj.setValue(50);
    int result = obj.subtract(20);
    REQUIRE(result == 30);
    REQUIRE(obj.getValue() == 30);
}

调试工具

GDB 调试器

GDB 是 Linux 下最常用的命令行调试器，功能强大但需要记忆一些命令。

基本操作

编译时务必添加 -g 参数以包含调试信息：

g++ -g program.cpp -o program

启动后常用命令如下：

gdb program
break main          # 在 main 函数处设置断点
run                 # 运行程序
next                # 执行下一行（不进入函数）
step                # 执行下一行（进入函数）
print variable      # 打印变量值
watch variable      # 监听变量变化
backtrace           # 打印调用栈
continue            # 继续执行
quit                # 退出

调试示例

假设遇到逻辑错误，可以这样排查：

#include <iostream>
#include "MyClass.h"

int main() {
    MyClass obj;
    obj.setValue(42);
    int result = obj.add(20);
    std::cout << "结果：" << result << std::endl;
    return 0;
}

Visual Studio 调试器

如果你使用 Windows 环境，Visual Studio 提供的图形化调试器体验更佳，支持断点、变量查看、调用栈等功能。

调试步骤

1. 在代码左侧点击设置断点。
2. 按 F5 启动调试。
3. 程序会在断点处暂停。
4. 利用调试窗口查看变量值和调用栈。
5. 根据需要单步执行或继续。

集成测试

基本概念

集成测试关注模块间的交互。常见的集成策略包括：

• 自顶向下：从顶层模块开始，逐步集成底层。
• 自底向上：从底层模块开始，逐步集成顶层。
• 三明治集成：结合上述两种方法。

示例

这里展示了一个简单的计算器解析器与计算器的集成测试：

#include <gtest/gtest.h>
#include "Calculator.h"
#include "Parser.h"

// 测试 Calculator 和 Parser 的集成功能
TEST(IntegrationTest, CalculateTest) {
    Calculator calculator;
    Parser parser;

    // 测试加法
    std::string expression = "10 + 20";
    int result = parser.parse(expression);
    EXPECT_EQ(result, 30);

    // 测试乘法
    expression = "10 * 20";
    result = parser.parse(expression);
    EXPECT_EQ(result, 200);

    // 测试括号
    expression = "(10 + 20) * 3";
    result = parser.parse(expression);
    EXPECT_EQ(result, 90);
}

综合案例：实现一个简单的计算器并进行测试

为了巩固所学，我们构建一个完整的计算器项目，涵盖项目结构、核心代码、测试及构建流程。

项目结构

CalculatorProject/
├── include/
│   ├── Calculator.h
│   └── Parser.h
├── src/
│   ├── Calculator.cpp
│   ├── Parser.cpp
│   └── main.cpp
├── tests/
│   ├── CalculatorTest.cpp
│   ├── ParserTest.cpp
│   └── IntegrationTest.cpp
└── CMakeLists.txt

核心代码

Calculator.h

#ifndef CALCULATOR_H
#define CALCULATOR_H

class Calculator {
public:
    static int add(int a, int b);
    static int subtract(int a, int b);
    static int multiply(int a, int b);
    static int divide(int a, int b);
};

#endif // CALCULATOR_H

Calculator.cpp

#include "Calculator.h"
#include <stdexcept>

int Calculator::add(int a, int b) {
    return a + b;
}

int Calculator::subtract(int a, int b) {
    return a - b;
}

int Calculator::multiply(int a, int b) {
    return a * b;
}

int Calculator::divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("除数不能为零");
    }
    return a / b;
}

Parser.h

#ifndef PARSER_H
#define PARSER_H

#include <string>
#include "Calculator.h"

class Parser {
public:
    int parse(const std::string& expression);
};

#endif // PARSER_H

Parser.cpp

#include "Parser.h"
#include <sstream>

int Parser::parse(const std::string& expression) {
    std::istringstream iss(expression);
    int a, b;
    char op;
    iss >> a >> op >> b;

    switch (op) {
    case '+': return Calculator::add(a, b);
    case '-': return Calculator::subtract(a, b);
    case '*': return Calculator::multiply(a, b);
    case '/': return Calculator::divide(a, b);
    default: throw std::invalid_argument("无效的运算符");
    }
}

main.cpp

#include <iostream>
#include "Parser.h"

int main() {
    Parser parser;
    try {
        std::string expression;
        std::cout << "请输入表达式（例如：10 + 20）: ";
        std::getline(std::cin, expression);
        int result = parser.parse(expression);
        std::cout << "结果：" << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "错误：" << e.what() << std::endl;
        return 1;
    }
    return 0;
}

CalculatorTest.cpp

#include <gtest/gtest.h>
#include "Calculator.h"

TEST(CalculatorTest, AddTest) {
    EXPECT_EQ(Calculator::add(10, 20), 30);
    EXPECT_EQ(Calculator::add(-10, 20), 10);
    EXPECT_EQ(Calculator::add(0, 0), 0);
}

TEST(CalculatorTest, SubtractTest) {
    EXPECT_EQ(Calculator::subtract(20, 10), 10);
    EXPECT_EQ(Calculator::subtract(10, 20), -10);
    EXPECT_EQ(Calculator::subtract(0, 0), 0);
}

TEST(CalculatorTest, MultiplyTest) {
    EXPECT_EQ(Calculator::multiply(10, 20), 200);
    EXPECT_EQ(Calculator::multiply(-10, 20), -200);
    EXPECT_EQ(Calculator::multiply(0, 10), 0);
}

TEST(CalculatorTest, DivideTest) {
    EXPECT_EQ(Calculator::divide(20, 10), 2);
    EXPECT_EQ(Calculator::divide(-20, 10), -2);
    EXPECT_THROW(Calculator::divide(10, 0), std::invalid_argument);
}

ParserTest.cpp

#include <gtest/gtest.h>
#include "Parser.h"

TEST(ParserTest, ParseTest) {
    Parser parser;
    EXPECT_EQ(parser.parse("10 + 20"), 30);
    EXPECT_EQ(parser.parse("20 - 10"), 10);
    EXPECT_EQ(parser.parse("10 * 20"), 200);
    EXPECT_EQ(parser.parse("20 / 10"), 2);
    EXPECT_THROW(parser.parse("10 / 0"), std::invalid_argument);
    EXPECT_THROW(parser.parse("10 a 20"), std::invalid_argument);
}

IntegrationTest.cpp

#include <gtest/gtest.h>
#include "Parser.h"

TEST(IntegrationTest, CalculateTest) {
    Parser parser;
    EXPECT_EQ(parser.parse("10 + 20"), 30);
    EXPECT_EQ(parser.parse("20 - 10"), 10);
    EXPECT_EQ(parser.parse("10 * 20"), 200);
    EXPECT_EQ(parser.parse("20 / 10"), 2);
    EXPECT_THROW(parser.parse("10 / 0"), std::invalid_argument);
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.10)
project(CalculatorProject)

set(CMAKE_CXX_STANDARD 17)
include_directories(include)

add_library(Calculator src/Calculator.cpp)
add_library(Parser src/Parser.cpp)

add_executable(CalculatorApp src/main.cpp)
target_link_libraries(CalculatorApp Calculator Parser)

add_subdirectory(tests)

tests/CMakeLists.txt

cmake_minimum_required(VERSION 3.10)
find_package(GTest REQUIRED)
include_directories(${GTEST_INCLUDE_DIRS})

add_executable(CalculatorTests CalculatorTest.cpp ParserTest.cpp IntegrationTest.cpp)
target_link_libraries(CalculatorTests ${GTEST_LIBRARIES} Calculator Parser pthread)
include(GoogleTest)
gtest_discover_tests(CalculatorTests)

构建与测试

mkdir -p build && cd build
cmake ..
make
ctest

总结与练习

本章涵盖了 C++ 测试与调试的核心内容，包括测试分类、Google Test 和 Catch2 的使用、GDB 及 VS 调试技巧、集成测试方法以及完整的计算器实战案例。

练习题

1. 编写程序，使用 Google Test 测试一个简单的链表数据结构。
2. 编写一个函数，尝试使用 GDB 调试内存泄漏问题。
3. 使用 Visual Studio 调试器调试多线程程序。
4. 实现一个类，并使用 Catch2 测试其功能。
5. 编写集成测试，验证一个简单的银行账户系统。

进阶挑战

1. 研究如何使用 Google Mock 进行模拟对象测试。
2. 学习使用 Google Benchmark 进行性能基准测试。
3. 探索 gcov 等代码覆盖率工具的使用。
4. 了解 Clang Static Analyzer 等静态分析工具。
5. 配置 GitHub Actions 实现持续集成自动化测试。