C++在线五子棋对战（网页版）项目：实用工具类模块代码实现

在线五子棋项目中需要用到的实用工具模块：

1.日志宏：实现程序日志打印

2.mysql_util:数据库的连接和初始化，句柄的消耗，语句的执行

3.json_util：封装实现json的序列化和反序列化

4.string_util：封装实现字符串分割功能

5.file_util：封装文件数据的读取功能（html文件数据的读取）

1.日志宏封装

日志宏的实现，主要实现程序日志的打印。比如打印：

[08:29:32 main.c:28] 文件打开失败。其意思是：在八点29分32秒，在main.c文件的第二十八行，出现了一个主要的错误，该错误为文件打开失败。这时候，我们查看日志，就可以找到错误在哪了。

需要用到的一些接口：

time_t time(NULL);//获取系统时间戳

struct tm *localtime(time_t *t);//根据生成的时间戳，生成一个时间的结构体

//将时间结构体，按照一定的格式组织成字符串放在char空间中，max为s的大小
size_t strftime(char *s,size_t max, const char *format,const struct tm *tm);

//将数据按照一定的格式，写入文件fp中
int fprintf(FILE *fp,char *format,...);

日志宏的实现

#ifndef _M_LOGGER_H_  和 #define _M_LOGGER_H_是预处理器指令，用于防止头文件被重复包含。如果头文件已经被包含了，那么这对指令将会被跳过。

#define部分定义了几个宏常量：

INF 表示正常的日志等级，定义为0。
DBG表示调试信息的日志等级，定义为1。
ERR表示错误信息的日志等级，定义为2。
DEFAULT_LOG_LEVEL表示默认的日志等级，定义为 DBG。

LOG宏定义了一个用于打印日志的函数：

level是日志的等级，用于控制是否打印该日志。
format是日志的格式字符串，类似于 printf 函数。
... 是可变参数，用于传递给格式字符串的值。
do{...}while(0)是为了使该宏可以像函数一样使用。
在宏内部，首先检查DEFAULT_LOG_LEVEL是否大于指定的level，如果是，则跳过后续的代码。然后，获取当前时间，并将其格式化为字符串。最后，使用fprintf函数将日志输出到标准输出流 stdout，包括时间、文件名、行号和格式化的日志内容。

ILOG、DLOG 和 ELOG 是基于 LOG 宏定义的更具体的日志打印函数，分别用于记录正常、调试和错误信息的日志。它们的定义中，会调用 LOG 宏并指定相应的日志等级。

#endif` 表示预处理器指令结束。

其中：通过在宏定义中的 ## 操作符，可以在只有可变参数列表的情况下正常展开，如果没有可变参数传入，则 ## 会将他们连接为空，避免了语法错误。

#ifndef _M_LOGGER_H_
#define _M_LOGGER_H_
#include
#include

#define INF 0 //正常
#define DBG 1 //调试信息
#define ERR 2 //错误信息
#define DEFAULT_LOG_LEVEL DBG //默认日志等级
#define LOG(level,format,...) do{\
    if(DEFAULT_LOG_LEVEL > level) break;\
    time_t t = time(NULL);\
    struct tm *lt = localtime(&t);\
    char buf[32] = {0};\
    strftime(buf,31,"%H:%M:%S",lt);\
    fprintf(stdout,"[%s %s:%d] " format "\n",buf,__FILE__,__LINE__, ##__VA_ARGS__);\
}while(0)

#define ILOG(format,...) LOG(INF,format, ##__VA_ARGS__)
#define DLOG(format,...) LOG(DBG,format, ##__VA_ARGS__)
#define ELOG(format,...) LOG(ERR,format, ##__VA_ARGS__)

#endif

#include"logger.hpp"

int main()
{
    ILOG("五子棋");
    DLOG("项目");
    ELOG("666");
    return 0;
}

mysql_util封装

关于C PAI，请移步-->https://mp.csdn.net/mp_blog/creation/editor/131496582

class mysql_util
{
public:
    //创建数据库的接口：这个接口包含初始化句柄、连接服务器、设置字符集和选择数据库
    /*host:主机名 username：用户名 ossword: 密码 dbname: 要使用的数据库名 port：MYSQL数据库端口号*/
    static MYSQL *mysql_create(const std::string &host,
    const std::string &username,
    const std::string &password,
    const std::string &dbname,
    uint16_t port = 3306)
    {
        //1. 初始化MySQL句柄
        //MYSQL *mysql_init(MYSQL *mysql);
        MYSQL *mysql = mysql_init(NULL);
        if(mysql==NULL)
        {
            ELOG("mysql init failed!");
            return nullptr;
        }

        //2. 连接服务器
        //MYSQL *mysql_real_connect(mysql,host,user,pass,dbname,port,unix_socket,flag)
        if(mysql_real_connect(mysql,host.c_str(),username.c_str(),password.c_str(),dbname.c_str(),port,NULL,0)==NULL)
        {
            ELOG("connect mysql server failed :%s",mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }

        //3.设置客户端字符集
        //int mysql_set_character_set(mysql,"utf8");
        if(mysql_set_character_set(mysql,"utf8")!=0)
        {
            ELOG("set client character failed :%s",mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }

        return mysql;
    }

    //执行语句
    static bool mysql_exec(MYSQL *mysql,const std::string &sql)
    {
        int ret = mysql_query(mysql,sql.c_str());
        if(ret!=0)
        {
            ELOG("%s\n",sql.c_str());
            ELOG("mysql query failed :%s\n",mysql_error(mysql));
            mysql_close(mysql);
            return false;
        }
        return true;
    }
    //释放句柄
    static void mysql_destory(MYSQL *mysql)
    {
        if(mysql!=nullptr)
        {
            mysql_close(mysql);
        }
        return;
    }
};

Jsoncpp-API封装

Json的接口介绍，请移步-->Jsoncpp的使用

#include "logger.hpp"
#include 
#include 
#include
#include
#include

class json_util
{
public:
    static bool serialize(const Json::Value &root,std::string &str)
    {
        Json::StreamWriterBuilder swb;
        std::unique_ptrsw(swb.newStreamWriter());
        std::stringstream ss;
        int ret = sw->write(root,&ss);
        if(ret!=0)
        {
            ELOG("Json serialize failed!");
            return false;
        }
        str = ss.str();
        return true;
    }
    static bool unserialize(const std::string &str ,Json::Value &root)
    {
        Json::CharReaderBuilder crb;
        std::unique_ptr cr(crb.newCharReader());
        std::string err;
        bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root,&err);
        if (ret==false) 
        {
            ELOG("UnSerialize failed!");
            return false;
        }
        return true;
    }

};

string_util字符串分割函数的封装

定义一个静态成员函数split，参数有src，sep和res，其作用分别是：src为需要分割的字符串，sep为分隔符，res是将分割后的字符存储起来。

定义pos，先找到第一个分隔符，然后判断是否可以找到，如果找不到，说明src里面已经没用分隔符了，那么就将src从idx的位置开始的整个字符串放到res中。

如果找到了，首先需要判断分隔符的位置和子字符串的起始位置是否相同，如果相同，说明当前位置的字符是一个分隔符，idx需要往后走。

如果位置不相同，那么就将src中，从idx这个位置，长pos-idx的字符串分割出来放到res中。

class string_util
{
public:
    static int split(const std::string& src,const std::string& sep,std::vector& res)
    {
        size_t pos,idx = 0;
        while(idx

file_util

参数说明：将filename中的数据读取到body中。

class file_util
{
public:
    static bool read(const std::string& filename,std::string& body)
    {
        //打开文件
        std::ifstream ifs(filename,std::ios::binary);
        if(ifs.is_open()==false)
        {
            ELOG("%s file open failed!",filename.c_str());
            return false;
        }
        //获取文件大小
        size_t fsize = 0;
        ifs.seekg(0,std::ios::end);//偏移量为0，跳转到文件末尾
        fsize = ifs.tellg();//获取当前读写文件相对于文件起始位置的偏移量
        ifs.seekg(0,std::ios::beg);//放回起始位置
        body.resize(fsize);
        //将文件数据读取
        ifs.read(&body[0],fsize);//不能使用body.c_str()，因为它返回的是一个const的起始地址，不能被修改
        if(ifs.good()==false)
        {
            ELOG("read %s file content failed",filename.c_str());
            ifs.close();
            return false;
        }
        //关闭文件
        ifs.close();
        return true;
    }

};