【C++项目】从零实现一个在线编译器

前言

身为一名程序员，想必大家都有接触过像leetcode这样的刷题网站，不知你们在刷题的过程中是否思考过一个问题：它们是如何实现在线编译运行的功能。如果你对此感到好奇，那么本文将一步步带你来实现一个简易在线编译器。

项目概述

项目的基本逻辑：前端用户在网页上输入代码与参数，后端通过多进程的方式来编译运行代码，然后将标准输出、标准错误信息返回给前端页面。

前后端交互数据格式

// 前端发送
{
  "code": "代码",
  "cpu_limit": "CPU限制",
  "mem_limit": "内存限制"
}

// 后端发送
{
  "reason": "错误原因",
  "status": "状态码",
  "stderr": "错误输出",
  "stdout": "标准输出"
}

使用的第三方库

后端：

cpp-httplib：用于处理HTTP请求和响应。
jsoncpp：用于解析和生成JSON数据。
spdlog：用于日志记录。

前端：

jquery：简化JavaScript操作，方便进行DOM操作和Ajax请求。
ace：提供代码编辑器功能，支持语法高亮和代码自动完成。

运行效果

具体实现

后端逻辑

后端分为编译模块和运行模块，均使用多进程的方式来运行，并根据用户所选语言的语言来选择不同的编译器和运行方式。后端代码分为四部分：公共模块（工具类）、编译模块、运行模块、编译运行模块（整合编译与运行）。

公共模块

日记类

日记系统对spdlog进行了最低程度的封装，实现了单例日记系统，并定义宏来简化其使用。

//
// Created by lang liu on 24-4-23.
//

#pragma once

#ifdef DEBUG
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#endif

#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>

namespace ns_log {
    //TODO 初始化日记 完善
    class Log {
    public:
        static Log &getInstance() {
            std::call_once(_flag, []() {
                _instance = new Log();
            });
            return *_instance;
        }

        auto getLogger()
        ->std::shared_ptr<spdlog::logger>
        {
            return _logger;
        }

    private:
        Log() {
            _logger = spdlog::stdout_color_mt("nil");
            _logger->set_level(spdlog::level::debug);
            _logger->set_pattern("[%^%l%$] [%Y-%m-%d %H:%M:%S] [%t] [%s:%#] %v");
        }

        ~Log() {
            spdlog::drop_all();
        }

    private:
        static std::once_flag _flag;
        static Log *_instance;

        std::shared_ptr<spdlog::logger> _logger;
    };

    std::once_flag Log::_flag;
    Log *Log::_instance = nullptr;


#define LOG_DEBUG(...)    SPDLOG_LOGGER_DEBUG(Log::getInstance().getLogger(), __VA_ARGS__)
#define LOG_INFO(...)     SPDLOG_LOGGER_INFO(Log::getInstance().getLogger(), __VA_ARGS__)
#define LOG_WARN(...)     SPDLOG_LOGGER_WARN(Log::getInstance().getLogger(), __VA_ARGS__)
#define LOG_ERROR(...)    SPDLOG_LOGGER_ERROR(Log::getInstance().getLogger(), __VA_ARGS__)
#define LOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(Log::getInstance().getLogger(), __VA_ARGS__)
}


// #else
//[x] 无spdlog
// #include <iostream>
// #include <format>
// #include "util.hpp"

// namespace ns_log {

//     using namespace ns_util;

//     enum {
//         INFO,
//         DEBUG,
//         WARN,
//         ERROR,
//         CRITICAL
//     };

//     inline std::ostream &Log(const std::string &level, const std::string &str) {
//         std::string msg = std::format("[{}] [{}] [{}:{}] {}", level, TimeUtil::GetTimeStamp(), __FILE__, __LINE__,
//                                       str);
//         // auto ret = __FILE_NAME__;
//         return std::cout << msg;
//     }

// #define LOG_INFO(...)     Log("INFO", __VA_ARGS__)
// #define LOG_DEBUG(...)    Log("DEBUG", __VA_ARGS__)
// #define LOG_WARN(...)     Log("WARN", __VA_ARGS__)
// #define LOG_ERROR(...)    Log("ERROR", __VA_ARGS__)
// #define LOG_CRITICAL(...) Log("CRITICAL", __VA_ARGS__)

// }

// #endif

工具类

工具类分为时间工具、文件工具、路径工具。

时间工具：时间工具类用于生成时间戳，辅助文件工具生成唯一的文件名（UUID）。

文件工具：用于实现读写、创建、删除文件。

路径工具：用于更改文件的后缀。

//
// Created by lang liu on 24-4-23.
//

#ifndef OJ_UTIL_HPP
#define OJ_UTIL_HPP

#include "log.hpp"
#include <sys/time.h>
#include <sys/stat.h>
#include <fstream>
#include <atomic>
#include <unordered_map>
#include <filesystem>
#include <vector>

namespace ns_util
{
    using namespace ns_log;

    // 定义文件后缀名的映射表
    static inline std::unordered_map<std::string, std::string> suffixTable {
        {"c_cpp", ".cc"},
        {"csharp", ".cs"},
        {"python", ".py"},
        {"javascript", ".js"}
    };

    // 定义可执行文件后缀名的映射表
    static inline std::unordered_map<std::string, std::string> excuteTable {
        {"c_cpp", ".exe"},
        {"csharp", ".cs"},
        {"javascript", ".js"},
        {"python", ".py"}
    };

    // 时间工具类
    class TimeUtil
    {
    public:
        // 获取时间戳（秒）
        static std::string GetTimeStamp()
        {
            struct timeval _tv{};
            gettimeofday(&_tv, nullptr);    // 获取时间戳
            return std::to_string(_tv.tv_sec);
        }

        // 获取时间戳（毫秒），用于生成随机文件名
        static std::string GetTimeNs()
        {
            struct timeval _tv{};
            gettimeofday(&_tv, nullptr);
            return std::to_string(_tv.tv_sec * 1000 + _tv.tv_usec / 1000);
        }
    };

    // 文件路径和后缀名变量
    static std::string path;
    static std::string srcSuffix;
    static std::string excuteSuffix;
    static const std::string temp_path = "./template/";

    // 路径工具类
    class PathUtil
    {
    public:
        // 初始化模板路径和后缀名
        static void InitTemplate(const std::string& lang) {
            path = temp_path + lang + "/";
            srcSuffix = suffixTable.at(lang);
            excuteSuffix = excuteTable.at(lang);
        }

        // 添加后缀名到文件名
        static std::string AddSuffix(const std::string &file_name, const std::string& suffix)
        {
            std::string path_name = path;
            path_name += file_name;
            path_name += suffix;
            return path_name;
        }

        // 获取源文件路径
        static std::string Src(const std::string& file_name)
        {
            return AddSuffix(file_name, srcSuffix);
        }

        // 获取可执行文件路径
        static std::string Exe(const std::string& file_name)
        {
            return AddSuffix(file_name, excuteSuffix);
        }

        // 获取编译错误文件路径
        static std::string CompilerError(const std::string& file_name)
        {
            return AddSuffix(file_name, ".compile_error");
        }

        // 获取标准输入文件路径
        static std::string Stdin(const std::string& file_name)
        {
            return AddSuffix(file_name, ".stdin");
        }

        // 获取标准输出文件路径
        static std::string Stdout(const std::string& file_name)
        {
            return AddSuffix(file_name, ".stdout");
        }

        // 获取标准错误文件路径
        static std::string Stderr(const std::string& file_name)
        {
            return AddSuffix(file_name, ".stderr");
        }
    };

    // 文件工具类
    class FileUtil
    {
    public:
        // 移除文件夹中的所有文件（递归）
        static void RemoveAllFile(const std::string& dir) {
            std::vector<std::filesystem::path> removeArray;

            try {
                for(auto& it : std::filesystem::directory_iterator(dir)) {
                    if(std::filesystem::is_regular_file(it.path()))
                        removeArray.push_back(it.path());
                    else if (std::filesystem::is_directory(it.path()))
                        RemoveAllFile(it.path().string());
                }

                for(auto& it : removeArray) {
                    std::filesystem::remove(it);
                }
            }
            catch (const std::filesystem::filesystem_error& e) {
                LOG_ERROR("移除全部文件失败: {}", e.what());
            }
        }

        // 移除指定文件
        static void RemoveFile(const std::string& filename) {
            if(std::filesystem::exists(filename)) {
                std::filesystem::remove(filename);
            }
        }

        // 检查文件是否存在
        static bool IsFileExists(const std::string & path_name)
        {
            struct stat st = {};
            if(stat(path_name.c_str(), &st) == 0)
                return true;

            return false;
        }

        // 生成全局唯一的文件名
        static std::string UniqFileName()
        {
            static std::atomic_uint id(0);
            ++id;
            std::string ms = TimeUtil::GetTimeNs();
            std::string uniq_id = std::to_string(id);
            return ms + uniq_id;
        }

        // 将内容写入文件
        static bool WriteFile(const std::string & path_name, const std::string & content)
        {
            std::ofstream out(path_name);
            if(!out.is_open())
            {
                LOG_ERROR("write file failed!");
                return false;
            }
            out.write(content.c_str(), (int)content.size());
            out.close();
            return true;
        }

        // 读取文件内容
        static bool ReadFile(const std::string& path_name, std::string* content)
        {
            content->clear();

            std::ifstream in(path_name);
            if(!in.is_open())
            {
                LOG_ERROR("read file({}) failed!", path_name.c_str());
                return false;
            }
            in.seekg(0, std::ios::end);
            auto size = in.tellg(); // 获取文件大小
            in.seekg(0, std::ios::beg);

            content->resize(size);
            in.read(content->data(), size);

            return true;
        }
    };

};

#endif //OJ_UTIL_HPP

编译模块

编译模块因为其大部分代码都是相似的，所以这里将其具体执行逻辑分离开来，并使用工厂模式决定实例化不同的类。

编译模块

#pragma once

#include <unistd.h>
#include <sys/fcntl.h>

#include "log.hpp"
#include "util.hpp"

namespace ns_compiler {
    using namespace ns_log;
    using namespace ns_util;

    // 编译器基类
    class Compiler {
    public:
        virtual ~Compiler() = default;

        // 编译函数，接受文件名作为参数
        int Compile(const std::string& file_name) {
            // 打开标准错误和标准输出文件
            int _stderr = open(PathUtil::Stderr(file_name).c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
            int _stdout = open(PathUtil::Stdout(file_name).c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);

            // 检查文件是否成功打开
            if(_stderr < 0 || _stdout < 0) {
                LOG_ERROR("打开文件失败");
                return -1;
            }

            // 创建子进程进行编译
            pid_t pid = fork();
            if(pid < 0 ) {
                LOG_ERROR("线程创建失败: {}", strerror(errno));
                return -1;
            }
            else if(pid == 0) {
                // 子进程
                umask(0); // 重置文件掩码

                // 重定向标准错误和标准输出到文件
                dup2(_stderr, STDERR_FILENO);
                dup2(_stdout, STDOUT_FILENO);

                // 执行编译命令
                Execute(file_name);
                LOG_INFO("exec错误：{}", strerror(errno));
                return -1; // exec 出错
            }

            // 父进程等待子进程结束
            waitpid(pid, nullptr, 0);

            // 检查编译后的可执行文件是否存在
            if(!FileUtil::IsFileExists(PathUtil::Exe(file_name))) {
                LOG_INFO("文件编译失败");
                return -2;
            }
            return 0; // 编译成功
        }

    protected:
        // 执行具体编译命令的纯虚函数，需由子类实现
        virtual void Execute(const std::string& filename) = 0;
    };

    // C++ 编译器类，继承自 Compiler
    class CppCompiler : public Compiler {
    protected:
        // 执行 g++ 编译命令
        void Execute(const std::string& filename) override {
            execlp("g++", "g++", "-o", PathUtil::Exe(filename).c_str(),
                PathUtil::Src(filename).c_str(), nullptr);
        }
    };

    // 编译器工厂类，用于创建编译器对象
    class CompilerFactory {
    public:
        // 根据语言创建相应的编译器对象
        static std::unique_ptr<Compiler> CreateCompiler(const std::string& lang) {
            if(lang == "c_cpp")
                return std::make_unique<CppCompiler>();
            // 如果需要支持其他语言，可以在这里添加相应的编译器创建逻辑
            else
                return {};
        }
    };
}

运行模块

运行模块与编译模块的逻辑其实相差不大。

#pragma once

#include "compiler.hpp"
#include <iostream>
#include <sys/resource.h>
#include <sys/wait.h>

using namespace ns_log;
using namespace ns_util;

// Runner 基类，负责运行已编译的程序
class Runner {
public:
    // 运行指定的程序文件，并限制其 CPU 和内存使用
    int Run(const std::string& filename, const int cpu_limit, const int mem_limit) {
        // 获取输入、输出和错误文件路径
        std::string _execute = PathUtil::Exe(filename);
        std::string _stdin = PathUtil::Stdin(filename);
        std::string _stdout = PathUtil::Stdout(filename);
        std::string _stderr = PathUtil::Stderr(filename);

        umask(0); // 重置文件掩码
        // 打开标准输入、输出和错误文件
        int stdin_fd = open(_stdin.c_str(), O_CREAT | O_WRONLY, 0644);
        int stdout_fd = open(_stdout.c_str(), O_CREAT | O_WRONLY, 0644);
        int stderr_fd = open(_stderr.c_str(), O_CREAT | O_WRONLY, 0644);

        // 创建子进程以执行程序
        pid_t pid = fork();
        if(pid < 0) {
            LOG_ERROR("fork error");
            close(stdin_fd);
            close(stdout_fd);
            close(stderr_fd);
            return -1;
        }
        else if(pid == 0) {
            // 子进程
            dup2(stdin_fd, STDIN_FILENO); // 重定向标准输入到文件
            dup2(stdout_fd, STDOUT_FILENO); // 重定向标准输出到文件
            dup2(stderr_fd, STDERR_FILENO); // 重定向标准错误到文件

            signal(SIGXCPU, [](int sig) { // 处理超时信号
                std::cerr << "timeout" << std::endl;
            });

            SetProcLimit(mem_limit, cpu_limit); // 设置进程资源限制
            Excute(_execute); // 执行具体的程序
            LOG_ERROR("execute error");
            exit(-1); // exec 出错
        }

        // 父进程等待子进程完成
        int status;
        waitpid(pid, &status, 0);
        close(stderr_fd);
        close(stdout_fd);
        close(stdin_fd);

        return WEXITSTATUS(status); // 返回子进程的退出状态
    }

    virtual ~Runner() = default;

protected:
    // 纯虚函数，由子类实现具体的执行逻辑
    virtual void Excute(const std::string& filename) = 0;

    // 设置进程的内存和 CPU 使用限制
    static void SetProcLimit(const int m_limit, const int c_limit) {
        rlimit memLimit{};
        memLimit.rlim_cur = m_limit * 1024; // 内存限制（KB 转换为字节）
        memLimit.rlim_max = RLIM_INFINITY; // 最大内存限制
        setrlimit(RLIMIT_AS, &memLimit);

        rlimit cpuLimit{};
        cpuLimit.rlim_cur = c_limit; // CPU 时间限制（秒）
        cpuLimit.rlim_max = RLIM_INFINITY; // 最大 CPU 时间限制
        setrlimit(RLIMIT_CPU, &cpuLimit);
    }
};

// C++ 运行器类，继承自 Runner
class CppRunner : public Runner {
protected:
    // 使用 execlp 执行编译后的 C++ 程序
    void Excute(const std::string& exec) override {
        execlp(exec.c_str(), exec.c_str(), nullptr);
    }
};

// C# 运行器类，继承自 Runner
class CsharpRunner : public Runner {
protected:
    // 使用 execlp 执行 C# 程序
    void Excute(const std::string &filename) override {
        execlp("dotnet", "dotnet", "run",  filename.c_str(), "--project", path.c_str(), nullptr);
    }
};

// JavaScript 运行器类，继承自 Runner
class JsRunner : public Runner {
protected:
    // 使用 execlp 执行 JavaScript 程序
    void Excute(const std::string &filename) override {
        execlp("node", "node", filename.c_str(), nullptr);
    }
};

// Python 运行器类，继承自 Runner
class PyRunner : public Runner {
protected:
    // 使用 execlp 执行 Python 程序
    void Excute(const std::string &filename) override {
        execlp("python3", "python3", filename.c_str(), nullptr);
    }
};

// 运行器工厂类，用于创建运行器对象
class RunnerFactory {
public:
    // 根据语言创建相应的运行器对象
    static std::unique_ptr<Runner> CreateRunner(const std::string& language) {
        if(language == "c_cpp")
            return std::make_unique<CppRunner>();
        else if (language == "csharp")
            return std::make_unique<CsharpRunner>();
        else if(language == "python")
            return std::make_unique<PyRunner>();
        else
            return std::make_unique<JsRunner>();
    }
};

编译运行模块

编译运行模块是编译模块与运行模块的整合，用于解析前端发送的信息，并编译运行，最后将结果返回给前端网页。

#pragma once

#include "runner.hpp"
#include "compiler.hpp"
#include "util.hpp"
#include <json/json.h>

using namespace ns_log;
using namespace ns_util;
using namespace ns_compiler;

// json 输入格式
// code: 代码
// language: 编译器
// cpu_limit: CPU 限制
// mem_limit: 内存限制

// json 输出格式
// reason: 错误原因
// status: 状态码
// stderr: 错误输出
// stdout: 标准输出

class CompileAndRun
{
private:
    // 将状态码转换为描述信息
    static std::string codeToDesc(int status) {
        static std::unordered_map<int, std::string> errTable = {
            {-1, "未知错误"},
            {-2, "编译错误"},
            {0, "运行成功"},
            // 更多状态码描述
        };
        return errTable[status];
    }

public:
    // 编译并运行
    static void Start(std::string& in_json, std::string* out_json)
    {
        // 转换 JSON 格式
        Json::Value in_value;
        Json::Value out_value;
        Json::Reader reader;

        if (!reader.parse(in_json, in_value))
        {
            LOG_ERROR("CompileAndRun::Start parse json error");
            return;
        }

        // 记录输入的 JSON 数据
        Json::StyledWriter styledWriter;
        LOG_DEBUG("in_value: {}", styledWriter.write(in_value));

        // 从 JSON 中提取参数
        std::string code = in_value["code"].asString();
        int cpu_limit = in_value["cpu_limit"].asInt();
        int mem_limit = in_value["mem_limit"].asInt();
        std::string lang = in_value["language"].asString();

        int status_code = 0;

        // 初始化模板路径和后缀名
        PathUtil::InitTemplate(lang);
        std::string file_name = FileUtil::UniqFileName(); // 生成唯一文件名

        // 创建编译器和运行器对象
        auto Cp = CompilerFactory::CreateCompiler(lang);
        auto Rn = RunnerFactory::CreateRunner(lang);

        if(code.empty())
        {
            // 如果代码为空，记录错误并设置状态码
            LOG_ERROR("CompileAndRun::Start code is empty");
            status_code = -1;
            goto END;
        }

        // 将代码写入文件
        if(!FileUtil::WriteFile(PathUtil::Src(file_name), code))
        {
            status_code = -1; // 其他错误
            goto END;
        }

        // 编译代码
        if(Cp)
        {
            if(Cp->Compile(file_name) < 0) {
                status_code = -2; // 编译错误
                goto END;
            }
        }

        // 运行编译后的程序
        status_code = Rn->Run(file_name, cpu_limit, mem_limit);
        if(status_code < 0)
        {
            status_code = -1; // 未知错误
            goto END;
        }
        else if(status_code > 0)
        {
            goto END;
        }

    END:
        // 构建输出 JSON 数据
        out_value["status"] = status_code;
        out_value["reason"] = codeToDesc(status_code);
        if(status_code == 0)
        {
            std::string _stdout;
            FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout); // 读取标准输出
            out_value["stdout"] = _stdout;
        }
        else
        {
            std::string _stderr;
            FileUtil::ReadFile(PathUtil::Stderr(file_name), &_stderr); // 读取错误输出
            out_value["stderr"] = _stderr;
        }

        Json::StyledWriter writer;
        *out_json = writer.write(out_value); // 将结果写入输出 JSON
        LOG_DEBUG("out_json: {}", *out_json);

        // 清理生成的文件
        RemoveFile(file_name);
    }

private:
    // 移除生成的文件
    static void RemoveFile(const std::string& filename) {
        auto filepath = path + filename;
        auto filesrc = filepath + srcSuffix;
        auto fileexe = filepath + excuteSuffix;

        auto fileout = PathUtil::Stderr(filename);
        auto filein = PathUtil::Stdin(filename);
        auto fileerr = PathUtil::Stdout(filename);

        FileUtil::RemoveFile(filesrc);
        FileUtil::RemoveFile(fileexe);
        FileUtil::RemoveFile(fileout);
        FileUtil::RemoveFile(filein);
        FileUtil::RemoveFile(fileerr);
    }
};

程序入口

#include "compile_run.hpp"
#include <httplib.h>


int main()
{
    using namespace httplib;
    using namespace ns_util;



    // system("pwd");

    Server svr;

    svr.set_base_dir("./wwwroot");
    
    svr.Post("/run", [](const Request & req, Response &res) {
        std::string in_json = req.body;
        std::string out_json;
        CompileAndRun::Start(in_json, &out_json);
        res.set_content(out_json, "application/json");
    });

    // 启动服务器
    
    svr.listen("0.0.0.0", 8080);

    return 0;
}