在这里插入图片描述
啊我摔倒了..有没有人扶我起来学习....

👱个人主页： $\color{Darkorange}{《CGod的个人主页》}$ 交个朋友叭~
💒个人社区： $\color{Darkorange}{《编程成神技术交流社区》}$ 加入我们，一起高效学习，收割好Offer叭~
🌱刷题链接： $\color{Darkorange}{《LeetCode》}$ 快速成长的渠道哦~

前言
一、所用技术与开发环境
二、项目介绍
三、项目开始
- 3.1 compile_server的设计
- - 3.1.1 complier编译功能
  - 3.1.2 runner运行功能
  - 3.1.3 complie_run编译运行功能
  - 3.1.4 compile_server调用以上功能
  - 3.1.5 使用Postman调试compile_server功能
- 3.2 基于MVC 结构的oj 服务设计
- - 3.2.1 用户请求的服务路由功能
  - 3.2.2 model功能，提供对数据的操作
  - 3.2.3 control功能，逻辑控制模块
  - 3.3.3 view功能，网页渲染模块

前言

本项目实现一个类似 leetcode 的题目列表+在线编程功能的负载均衡式在线OJ服务

一、所用技术与开发环境

所用技术:
1. C++ STL 标准库
2. Boost 准标准库(字符串切割)
3. cpp-httplib 第三方开源网络库
4. ctemplate 第三方开源前端网页渲染库
5. jsoncpp 第三方开源序列化、反序列化库
6. 负载均衡设计
7. 多进程、多线程
8. MySQL C connect
9. Ace前端在线编辑器(了解)
10. html/css/js/jquery/ajax (了解)
开发环境
1. Centos 7 云服务器
2. vscode
3. Mysql Workbench

二、项目介绍

项目核心是三个模块
1. comm：公共模块
2. compile_server：编译与运行模块
3. oj_server：获取题目列表，查看题目编写题目界面，负载均衡，其他功能
项目宏观结构
编写思路
1. compile_server
2. oj_server
3. version1 ——基于文件版的在线OJ
4. 前端的页面设计
5. version2 ——基于 MySQL 版的在线OJ

三、项目开始

3.1 compile_server的设计

提供的服务：编译并运行代码，得到格式化的相关的结果

3.1.1 complier编译功能

compile_server/compiler.hpp

namespace ns_compiler
{
    using namespace ns_util;
    using namespace ns_log;

    class Compiler
    {
    public:
        // 返回值：编译成功：true，否则：false
        // 输入参数：编译的文件名
        // file_name: 1234
        // 1234 -> ./temp/1234.cpp
        // 1234 -> ./temp/1234.exe
        // 1234 -> ./temp/1234.stderr
        static bool Compile(const std::string &file_name)
        {
            pid_t pid = fork();
            if (pid < 0)
            {
                logMessage(ERROR, "内部错误，创建子进程失败...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                return false;
            }
            else if (pid == 0)
            {
                umask(0);
                int _complie_stderr_fd = open(PathUtil::CompilerError(file_name).c_str(), O_CREAT | O_WRONLY, 0644);
                if (_complie_stderr_fd < 0)
                {
                    logMessage(FATAL, "没有成功形成stderr文件...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                    exit(1);
                }
                // 重定向标准错误到_complie_stderr_fd
                dup2(_complie_stderr_fd, 2);
                // 程序替换，并不影响进程的文件描述符表
                // 子进程: 调用编译器，完成对代码的编译工作
                // g++ -o target src -std=c++11
                execlp("g++", "g++", "-o", PathUtil::Exe(file_name).c_str(), PathUtil::Src(file_name).c_str(), "-std=c++11", "-D", "COMPILER_ONLINE", nullptr);
                logMessage(FATAL, "启动编译器g++失败，可能是参数错误...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                exit(2);
            }
            else
            {
                waitpid(pid, nullptr, 0);
                // 编译是否成功,就看有没有形成对应的可执行程序
                if (FileUtil::IsFileExists(PathUtil::Exe(file_name)))
                {
                    logMessage(NORMAL, "编译成功！");
                    return true;
                }
                logMessage(ERROR, "编译失败，没有形成可执行程序...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                return false;
            }
        }
    };
}

comm/log.hpp

namespace ns_log
{
    #define DEBUG 0
    #define NORMAL 1
    #define WARNING 2
    #define ERROR 3
    #define FATAL 4

    static const char *gLevelMap[] = {
        "DEBUG",
        "NORMAL",
        "WARNING",
        "ERROR",
        "FATAL"};
    static void logMessage(int level, const char *format, ...)
    {
        time_t timeStamp = time(nullptr);
        char stdBuffer[1024];
        snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld]", gLevelMap[level], timeStamp);

        va_list arg;
        va_start(arg, format);
        char usrBuffer[1024];
        vsnprintf(usrBuffer, sizeof stdBuffer, format, arg);
        va_end(arg);

        printf("%s %s\n", stdBuffer, usrBuffer);
    }
}

comm/util.hpp新增的接口有：

namespace ns_util
{
    const std::string temp_name = "./temp/";
    class PathUtil
    {
    public:
        static std::string AddSuffix(const std::string &file_name, const std::string &suffix)
        {
            std::string path_name = temp_name;
            path_name += file_name;
            path_name += suffix;
            return path_name;
        }
        // 1.编译时需要有的临时文件
        // 1.1构建源文件路径+后缀的完整文件名
        static std::string Src(const std::string &file_name)
        {
            return AddSuffix(file_name, ".cpp");
        }
        // 1.2构建可执行程序的完整路径+后缀名
        static std::string Exe(const std::string &file_name)
        {
            return AddSuffix(file_name, ".exe");
        }
        // 1.3构建编译错误时的完整路径+后缀名
        static std::string CompilerError(const std::string &file_name)
        {
            return AddSuffix(file_name, ".compile_error");
        }
    };

    class FileUtil
    {
    public:
        static bool IsFileExists(const std::string &path_name)
        {
            struct stat st;
            return stat(path_name.c_str(), &st) == 0;
        }
    };
}

3.1.2 runner运行功能

其中，我们需要引入资源限制功能，来限制用户提交的代码运行的占用时间和占用空间
分别测试一下时间资源限制和空间资源限制

test.cc

#include<iostream>
#include<sys/time.h>
#include<sys/resource.h>

int main()
{
	// 限制累计运行时长
	struct rlimit r;
	r.rlim_cur = 1; // 软限制，设置为1秒
	r.rlim_max = RLIM_INFINITY; // 硬限制，限制软限制的上限，这里设为无穷即可
	setrlimit(RLIMIT_CPU, &r);
	while(1);

	// 限制累计运行空间
	struct rlimit r;
	r.rlim_cur = 1024 * 1024 * 20; // 软限制，设置为20M
	r.rlim_max = RLIM_INFINITY; // 硬限制，限制软限制的上限，这里设为无穷即可
	setrlimit(RLIMIT_AS, &r);
	int count = 0;
	while(1)
	{
		int *p = new int[1024 * 1024];
		count++;
		std::cout << "size: " << count << std::endl;
		sleep(1);
	}
	return 0;
}

测试结果(进程分别收到24号信号SIGXCPU和6号信号SIGABRT而终止)：

编写运行功能

compile_server/runner.hpp

namespace ns_runner
{
    using namespace ns_util;
    using namespace ns_log;

    class Runner
    {
    public:
        // 提供设置进程占用资源大小的接口
        static void SetProcLimit(int _cpu_limit, int _mem_limit)
        {
            // 设置CPU时长
            struct rlimit cpu;
            cpu.rlim_cur = _cpu_limit;
            cpu.rlim_max = RLIM_INFINITY;
            setrlimit(RLIMIT_CPU, &cpu);

            // 设置内存大小
            struct rlimit mem;
            mem.rlim_cur = _mem_limit * 1024; // 转化成为KB
            mem.rlim_max = RLIM_INFINITY;
            setrlimit(RLIMIT_AS, &mem);
        }
        // 指明文件名即可，不需要代理路径，不需要带后缀
        /*******************************************
         * 返回值 > 0: 程序异常了，退出时收到了信号，返回值就是对应的信号编号
         * 返回值 == 0: 正常运行完毕的，结果保存到了对应的临时文件中
         * 返回值 < 0: 内部错误
         *
         * cpu_limit: 该程序运行的时候，可以使用的最大cpu资源上限
         * mem_limit: 改程序运行的时候，可以使用的最大的内存大小(KB)
         * *****************************************/
        static int Run(const std::string &file_name, int _cpu_limit, int _mem_limit)
        {
            /*********************************************
             * 程序运行：
             * 1. 代码跑完，结果正确
             * 2. 代码跑完，结果不正确
             * 3. 代码没跑完，异常了
             * Run需要考虑代码跑完，结果正确与否吗？？不考虑！
             * 结果正确与否：是由我们的测试用例决定的！
             * 我们只考虑：是否正确运行完毕
             *
             * 我们必须知道可执行程序是谁？
             * 一个程序在默认启动的时候
             * 标准输入: 不处理
             * 标准输出: 程序运行完成，输出结果是什么
             * 标准错误: 运行时错误信息
             * *******************************************/
            std::string _execute = PathUtil::Exe(file_name);
            std::string _stdin = PathUtil::Stdin(file_name);
            std::string _stdout = PathUtil::Stdout(file_name);
            std::string _stderr = PathUtil::Stderr(file_name);

            umask(0);
            int _stdin_fd = open(_stdin.c_str(), O_CREAT | O_RDONLY | O_TRUNC, 0644);
            int _stdout_fd = open(_stdout.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
            int _stderr_fd = open(_stderr.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
            if (_stdin_fd < 0 | _stdout_fd < 0 | _stderr_fd < 0)
            {
                logMessage(FATAL, "运行时打开标准文件失败...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                return -1; // 代表打开文件失败
            }

            pid_t pid = fork();
            if (pid < 0)
            {
                logMessage(FATAL, "运行时创建子进程失败...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                close(_stdin_fd);
                close(_stdout_fd);
                close(_stderr_fd);
                return -2; // 代表创建子进程失败
            }
            else if (pid == 0)
            {
                dup2(_stdin_fd, 0);
                dup2(_stdout_fd, 1);
                dup2(_stderr_fd, 2);

                execl(_execute.c_str() /*我要执行谁*/, _execute.c_str() /*我想在命令行上如何执行该程序*/, nullptr);
                exit(1);
            }
            else
            {
                close(_stdin_fd);
                close(_stdout_fd);
                close(_stderr_fd);
                int status = 0;
                waitpid(pid, &status, 0);
                // 程序运行异常，一定是因为因为收到了信号！
                logMessage(NORMAL, "运行完毕...info: %d | [%s][%d]: %s", status & 0x7F, __FILE__, __LINE__, strerror(errno));
                return status & 0x7F;
            }
        }
    };
}

comm/util.hpp新增的接口有：

namespace ns_util
{
    class PathUtil
    {
    public:
        // 2.运行时需要的临时文件
        // 2.1构建该程序对应的标准输入完整的路径+后缀名
        static std::string Stdin(const std::string &file_name)
        {
            return AddSuffix(file_name, ".stdin");
        }
        // 2.2构建该程序对应的标准输出完整的路径+后缀名
        static std::string Stdout(const std::string &file_name)
        {
            return AddSuffix(file_name, ".stdout");
        }
        // 2.3构建该程序对应的标准错误完整的路径+后缀名
        static std::string Stderr(const std::string &file_name)
        {
            return AddSuffix(file_name, ".stderr");
        }
    };
}

3.1.3 complie_run编译运行功能

首先引入一下jsoncpp功能，用于数据的序列化和反序列化
测试一下jsoncpp的使用
test.cc

#include<iostream>
#include<string>
#include<jsoncpp/json/json.h>

int main()
{
    // 序列化
    // 将结构化数据转化为字符串
    // value 是一个json的中间类， 可以填充kv值
    Json::Value root;
    root["code"] = "mycode";
    root["user"] = "bobo";
    root["age"]  = "27";

    // Json::FastWriter writer;
    Json::StyledWriter writer;
    std::string str = writer.write(root);
    std::cout << str << std::endl;
    return 0;
}

测试结果：

编写编译运行功能

complie_server/compile_run.hpp

namespace ns_compile_and_run
{
    using namespace ns_compiler;
    using namespace ns_runner;
    using namespace ns_log;
    using namespace ns_util;

    class CompileAndRun
    {
    public:
        static void RemoveTempFile(const std::string& file_name)
        {
            //清理文件的个数是不确定的，但是有哪些我们是知道的
            std::string _src = PathUtil::Src(file_name);
            if(FileUtil::IsFileExists(_src)) unlink(_src.c_str());

            std::string _compiler_error = PathUtil::CompilerError(file_name);
            if(FileUtil::IsFileExists(_compiler_error)) unlink(_compiler_error.c_str());

            std::string _execute = PathUtil::Exe(file_name);
            if(FileUtil::IsFileExists(_execute)) unlink(_execute.c_str());

            std::string _stdin = PathUtil::Stdin(file_name);
            if(FileUtil::IsFileExists(_stdin)) unlink(_stdin.c_str());

            std::string _stdout = PathUtil::Stdout(file_name);
            if(FileUtil::IsFileExists(_stdout)) unlink(_stdout.c_str());

            std::string _stderr = PathUtil::Stderr(file_name);
            if(FileUtil::IsFileExists(_stderr)) unlink(_stderr.c_str());
        }
        // code > 0 : 进程收到了信号导致异常奔溃
        // code < 0 : 整个过程非运行报错(代码为空，编译报错等)
        // code = 0 : 整个过程全部完成
        static std::string CodeToDesc(int status_code, const std::string &file_name)
        {
            std::string desc;
            switch (status_code)
            {
            case 0:
                desc = "编译运行成功";
                break;
            case -1:
                desc = "提交的代码是空";
                break;
            case -2:
                desc = "未知错误";
                break;
            case -3:
                // desc = "代码编译的时候发生了错误";
                FileUtil::ReadFile(PathUtil::CompilerError(file_name), &desc, true);
                break;
            case SIGABRT: // 6
                desc = "内存超过范围";
                break;
            case SIGXCPU: // 24
                desc = "CPU使用超时";
                break;
            case SIGFPE: // 8
                desc = "浮点数溢出";
                break;
            default:
                desc = "未知: " + std::to_string(status_code);
                break;
            }
            return desc;
        }
        /***************************************
         * 输入:
         * code： 用户提交的代码
         * input: 用户给自己提交的代码对应的输入，不做处理
         * cpu_limit: 时间要求
         * mem_limit: 空间要求
         *
         * 输出:
         * 必填
         * status: 状态码
         * reason: 请求结果
         * 选填：
         * stdout: 我的程序运行完的结果
         * stderr: 我的程序运行完的错误结果
         *
         * 参数：
         * in_json: {"code": "#include...", "input": "","cpu_limit":1, "mem_limit":10240}
         * out_json: {"status":"0", "reason":"","stdout":"","stderr":"",}
         * ************************************/
        static void start(const std::string &in_json, std::string *out_json)
        {
            Json::Value in_value;
            Json::Reader reader;
            reader.parse(in_json, in_value);

            std::string code = in_value["code"].asString();
            std::string input = in_value["input"].asString();
            int cpu_limit = in_value["cpu_limit"].asInt();
            int mem_limit = in_value["mem_limit"].asInt();

            std::string file_name; // 需要内部形成的唯一文件名
            int status_code = 0;
            int run_result = 0;
            Json::Value out_value;

            if (code.size() == 0)
            {
                status_code = -1; // 代码为空
                goto END;
            }
            // 形成的文件名只具有唯一性，没有目录没有后缀
            // 毫秒级时间戳+原子性递增唯一值: 来保证唯一性
            file_name = FileUtil::UniqFileName();
            // 形成临时src文件
            if (!FileUtil::WriteFile(PathUtil::Src(file_name), code))
            {
                status_code = -2; // 未知错误
                goto END;
            }

            if (!Compiler::Compile(file_name))
            {
                // 编译失败
                status_code = -3; // 代码编译的时候发生了错误
                goto END;
            }

            run_result = Runner::Run(file_name, cpu_limit, mem_limit);
            if (run_result < 0)
            {
                status_code = -2; // 未知错误
            }
            else if (run_result > 0)
            {
                status_code = run_result; // 程序运行崩溃了
            }
            else
            {
                status_code = 0; // 运行成功
            }
        END:
            out_value["status"] = status_code;
            out_value["reason"] = CodeToDesc(status_code, file_name);
            if (status_code == 0)
            {
                // 整个过程全部成功
                std::string _stdout;
                FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout, true);
                out_value["stdout"] = _stdout;

                std::string _stderr;
                FileUtil::ReadFile(PathUtil::Stderr(file_name), &_stderr, true);
                out_value["stderr"] = _stderr;
            }
            Json::StyledWriter writer;
            *out_json = writer.write(out_value);

            RemoveTempFile(file_name); // 清理临时文件
        }
    };
}

comm/util.hpp新增的接口有：

namespace ns_util
{
    class TimeUtil
    {
    public:
        // 获得毫秒时间戳
        static std::string GetTimeMS()
        {
            struct timeval _time;
            gettimeofday(&_time, nullptr);
            return std::to_string(_time.tv_sec * 1000 + _time.tv_usec / 1000);
        }
    };
    class FileUtil
    {
    public:
        static bool WriteFile(const std::string &path_name, const std::string &content)
        {
            std::ofstream out(path_name);
            if (!out.is_open())
            {
                return false;
            }
            out.write(content.c_str(), content.size());
            out.close();
            return true;
        }
        static bool ReadFile(const std::string &path_name, std::string *content, bool keep = false)
        {
            content->clear();

            std::ifstream in(path_name);
            if (!in.is_open())
            {
                return false;
            }
            std::string line;
            // getline:不保存行分割符,有些时候需要保留\n,
            // getline内部重载了强制类型转化
            while (std::getline(in, line))
            {
                (*content) += line;
                (*content) += keep ? "\n" : "";
            }
            in.close();
            return true;
        }
    };
}

3.1.4 compile_server调用以上功能

首先引入cpp-httplib的使用，把compile_server打包成网络服务
学习使用httplib
test.cc

#include"httplib.h"
using namespace httplib;

int main()
{
    Server svr;
    svr.Get("/bobo", [](const Request& req, Response& resp){
        resp.set_content("hello bobo!", "text/plain");
    });
    svr.listen("0.0.0.0", 9090); // 启动HTTP服务
    return 0;
}

启动服务(httplib提供多线程阻塞式网络服务)：
此时用浏览器访问：

编写compile_server.cc功能，把compile_server打包成网络服务
compile_server/compile_server.cc

void Usage(const std::string &command)
{
    std::cout << "Usage: " << command << " port" << std::endl;
}
// 编译服务随时可能被多个人请求，必须保证传递上来的code，形成源文件名称的时候，要具有
// 唯一性，要不然多个用户之间会互相影响
//./compile_server port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        return 1;
    }
    
    Server svr;
    svr.Post("/compile_and_run", [](const Request &req, Response &res){
        // 用户请求的服务正文是我们想要的json string
        std::string in_json = req.body;
        std::string out_json;
        if(!in_json.empty())
        {
            CompileAndRun::start(in_json, &out_json);
            res.set_content(out_json, "application/json;charset=utf-8");
        } 
    });
    svr.listen("0.0.0.0", atoi(argv[1])); // 启动http服务

    return 0;
}

3.1.5 使用Postman调试compile_server功能

在这里插入图片描述

3.2 基于MVC 结构的oj 服务设计

本质： 建立一个小型网站
1. 获取首页，用题目列表充当
2. 编辑区域页面
3. 提交判题功能(编译并运行)

M: Model,通常是和数据交互的模块，比如，对题库进行增删改查（文件版，MySQL）
V: view, 通常是拿到数据之后，要进行构建网页，渲染网页内容，展示给用户的(浏览器)
C: control, 控制器，就是我们的核心业务逻辑

3.2.1 用户请求的服务路由功能

oj_server/oj_server.cc

int main()
{
	Server svr; //用户请求的服务路由功能

    // 获取所有的题目列表
    svr.Get("/all_questions", [](const Request& req, Response& res){
        resp.set_content("这是所有题目的列表", "text/plain; charset=utf-8");
    });
    // 用户要根据题目编号，获取题目的内容
    // /question/100 -> 正则匹配
    // R"()", 原始字符串raw string,保持字符串内容的原貌，不用做相关的转义
    svr.Get(R"(/one_question/(\d+))", [&ctrl](const Request& req, Response& res){
       resp.set_content("这是指定的一道题: " + number, "text/plain; charset=utf-8");
});
    // 用户提交代码，使用我们的判题功能(1. 每道题的测试用例 2. compile_and_run)
    svr.Get(R"(/judge/(\d+))", [](const Request &req, Response &resp){
std::string number = req.matches[1];
	resp.set_content("指定题目的判题: " + number, "text/plain; charset=utf-8");
});

    svr.set_base_dir("./wwwroot");
    svr.listen("0.0.0.0", 8080);
    return 0;
}

3.2.2 model功能，提供对数据的操作

oj_server/oj_model.hpp

// 根据题目list文件，加载所有的题目信息到内存中
// model: 主要用来和数据进行交互，对外提供访问数据的接口
namespace ns_model
{
    using namespace ns_log;
    using namespace ns_util;

    class Question
    {
    public:
        std::string _number; //题目编号，唯一
        std::string _title;  //题目的标题
        std::string _star;   //难度: 简单 中等 困难
        int _cpu_limit;      //题目的时间要求(S)
        int _mem_limit;      //题目的空间要去(KB)
        std::string _desc;   //题目的描述
        std::string _head;   //题目预设给用户在线编辑器的代码
        std::string _tail;   //题目的测试用例，需要和header拼接，形成完整代码
    };

    const std::string questions_list = "./questions/questions.list";
    const std::string questions_path = "./questions/";

    class Model
    {
    public:
        Model()
        {
            LoadQuestionList(questions_list);
        }
        bool LoadQuestionList(const std::string &question_list)
        {
            //加载配置文件: questions/questions.list + 题目编号文件
            std::ifstream in(questions_list);
            if(!in.is_open())
            {
                logMessage(FATAL, "加载题库失败,请检查是否存在题库文件...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                return false;
            }

            std::string line;
            while(std::getline(in, line))
            {
                std::vector<std::string> tokens;
                StringUtil::SplitString(line, &tokens, " ");
                // 1 判断回文数 简单 1 30000
                if(tokens.size() != 5)
                {
                    logMessage(WARNING, "加载部分题目失败, 请检查文件格式...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                    continue;
                }
                Question q;
                q._number = tokens[0];
                q._title = tokens[1];
                q._star = tokens[2];
                q._cpu_limit = stoi(tokens[3]);
                q._mem_limit = stoi(tokens[4]);

                std::string path = questions_path;
                path += q._number;
                path += "/";

                FileUtil::ReadFile(path+"desc.txt", &(q._desc), true);
                FileUtil::ReadFile(path+"head.cpp", &(q._head), true);
                FileUtil::ReadFile(path+"tail.cpp", &(q._tail), true);

                _questions.insert({q._number, q});
            }
            logMessage(NORMAL, "加载题库...成功!");
            in.close();
            return true;
        }
        bool GetAllQuestions(std::vector<Question>* out)
        {
            if(_questions.size() == 0)
            {
                logMessage(ERROR, "用户获取题库失败...[%s][%d]: %s", __FILE__, __LINE__, strerror(errno));
                return false;
            }
            for(const auto& q : _questions) out->push_back(q.second);
            return true;
        }
        bool GetOneQuestion(const std::string &number, Question *question)
        {
            const auto& q = _questions.find(number);
            if(q == _questions.end())
            {
                logMessage(ERROR, "用户获取题目失败, 题目编号: %s | [%s][%d]: %s", number, __FILE__, __LINE__, strerror(errno));
                return false;
            }
            (*question) = q->second;
            return true;            
        }
    private:
        std::unordered_map<std::string, Question> _questions;
    };
}

comm/util.hpp新增接口

namespace ns_util
{
    class StringUtil
    {
    public:
        static void SplitString(const std::string& str, std::vector<std::string>* out, const std::string& sep)
        {
            boost::split(*out, str, boost::is_any_of(sep), boost::token_compress_on);
        }
    };
}

oj_server/questions/questions.list

1 回文串 简单 1 30000

oj_server/questions/1/desc.txt

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true
示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
进阶:

你能不将整数转为字符串来解决这个问题吗？

oj_server/questions/1/head.cpp

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

class Solution {
public:
    bool IsPalindrome(int x){
        
    }
};

oj_server/questions/1/tail.cpp

#ifndef COMPILE_ONLINE
    #include"head.cpp"
#endif

void test1()
{
    bool ret = Solution().IsPalindrome(1234321);
    if(ret) std::cout << "通过用例1, 测试121通过 ... OK!" << std::endl;
    else std::cout << "没有通过用例1, 测试的值是: 121"  << std::endl;
}
void test2()
{
    bool ret = Solution().IsPalindrome(-10);
    if(!ret) std::cout << "通过用例2, 测试-10通过 ... OK!" << std::endl;
    else std::cout << "没有通过用例2, 测试的值是: -10"  << std::endl;   
}
int main()
{
    test1();
    test2();
    return 0;
}

3.2.3 control功能，逻辑控制模块

3.3.3 view功能，网页渲染模块

首先引入ctemplate，提供网页渲染功能
测试使用一下ctemplate

test.cc

#include<ctemplate/template.h>
#include<string>
#include<iostream>

int main()
{
    std::string in_html = "./test.html";
    std::string value = "bobo";

    // 形成数据字典
    ctemplate::TemplateDictionary root("test"); // 理解为unordered_map<> test
    root.SetValue("key", value);                // 理解为test.insert({"key", value})

    // 获取被渲染网页对象
    ctemplate::Template* tpl = ctemplate::Template::GetTemplate(in_html, ctemplate::DO_NOT_STRIP);

    // 添加字典数据到网页中
    std::string out_html;
    tpl->Expand(&out_html, &root);

    // 完成了渲染
    std::cout << out_html << std::endl;
    return 0;
}

test.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>用来测试</title>
</head>
<body>
    <p>{{key}}</p>
    <p>{{key}}</p>
    <p>{{key}}</p>
    <p>{{key}}</p>
    <p>{{key}}</p>
</body>
</html>