综合练习

这一课你将能做到

1. 用类 + std::vector + std::variant + CMake 搭一个可运行的迷你判题器 CLI（submit / find）
2. 把 RAII 计时、optional 查询、variant 分派、移动语义串成一条完整链路
3. 为核心逻辑写 doctest 单测，并用 ASan 验证一次内存安全，完成工程闭环

为什么要学

前十一课的技能点是散落的，拼成真实项目才算内化。本课用最熟悉的在线判题场景串起它们：类建模、vector、variant、optional、RAII、CMake、单测加 ASan。写完这约 150 行，你对「C++ 工程长什么样」就有了肌肉记忆，再读真实判题沙箱等开源代码就有了坐标系。

先建立图像

mini-judge/
├── CMakeLists.txt        ← 构建声明（对应 pom.xml）
├── include/judge.hpp     ← 公共接口
├── src/judge.cpp         ← 判题核心
├── src/main.cpp          ← CLI 入口（main 唯一）
└── tests/test_judge.cpp  ← 单测（对应 JUnit）

跟着做

步骤 1：定义数据模型

新建 include/judge.hpp：

#pragma once

#include <optional>
#include <string>
#include <variant>
#include <vector>

namespace mj {

struct Submission {
    int id;
    std::string user;
    std::string code;
};

struct AC { int costMs; };
struct WA { int caseIdx; };
struct TLE { int limitMs; };
using Verdict = std::variant<AC, WA, TLE>;

class Judge {
public:
    explicit Judge(int timeLimitMs) : timeLimitMs_(timeLimitMs) {}
    Verdict judge(const std::string& code) const;
    std::optional<Verdict> resultOf(int submissionId) const;
    void submit(Submission s);
    const std::vector<Submission>& submissions() const { return subs_; }
private:
    int timeLimitMs_;
    std::vector<Submission> subs_;
    std::vector<std::pair<int, Verdict>> results_;
};

}  // namespace mj

步骤 2：实现判题核心

新建 src/judge.cpp：

#include "judge.hpp"

#include <algorithm>
#include <chrono>

namespace mj {

namespace {

// RAII 计时器：析构时写入耗时，异常路径也不漏
class ScopedTimer {
public:
    explicit ScopedTimer(int& outMs)
        : start_(std::chrono::steady_clock::now()), out_(outMs) {}
    ~ScopedTimer() {
        out_ = static_cast<int>(
            std::chrono::duration<double, std::milli>(
                std::chrono::steady_clock::now() - start_).count());
    }
private:
    std::chrono::steady_clock::time_point start_;
    int& out_;
};

// 模拟运行用户代码；真实沙箱在此 fork 子进程并限制资源
int runOneCase(const std::string& code, int caseIdx) {
    int h = 0;
    for (char c : code) h = h * 31 + c + caseIdx;
    return h % 200 + 1;
}

}  // namespace

Verdict Judge::judge(const std::string& code) const {
    for (int i = 0; i < 5; ++i) {
        int cost = 0;
        {
            ScopedTimer t(cost);
            cost += runOneCase(code, i);
        }
        if (cost > timeLimitMs_) return TLE{timeLimitMs_};
        if (i == 2 && code.find("wrong") != std::string::npos)
            return WA{i};
    }
    return AC{runOneCase(code, 0)};
}

void Judge::submit(Submission s) {
    int id = s.id;
    subs_.push_back(std::move(s));               // 移动避免深拷贝
    results_.emplace_back(id, judge(subs_.back().code));
}

std::optional<Verdict> Judge::resultOf(int submissionId) const {
    auto it = std::find_if(results_.begin(), results_.end(),
        [submissionId](const auto& rv) { return rv.first == submissionId; });
    if (it == results_.end()) return std::nullopt;
    return it->second;
}

}  // namespace mj