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 program.cpp -o program

# 启动 GDB
gdb program

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

调试示例

#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 调试器

Visual Studio 提供了强大的图形化界面，适合 Windows 环境下的开发。

调试步骤

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
cmake ..

# 编译项目
make

# 运行测试
ctest

总结与练习

本章涵盖了 C++ 测试与调试的核心内容，从基础概念到实战案例。掌握了这些技能后，你的代码可靠性将大幅提升。

推荐练习

1. 使用 Google Test 测试一个简单的链表数据结构
2. 编写函数并使用 GDB 调试内存泄漏问题
3. 利用 Visual Studio 调试器排查多线程程序问题
4. 用 Catch2 测试自定义类的功能
5. 为银行账户系统设计集成测试方案

进阶方向

• 研究 Google Mock 进行模拟对象测试
• 学习 Google Benchmark 进行性能分析
• 使用 gcov 获取代码覆盖率报告
• 结合 Clang Static Analyzer 进行静态检查
• 通过 GitHub Actions 实现持续集成自动化测试