接下来我们就可以对读取的数据进行处理了！！！怎么处理呢？我们还是跟自定义协议那篇一样，搞一个计算器好了！

Caculater函数

Response Caculater(const Request& req)
{
    Response resp;//构造函数中已经指定了exitcode为0
    switch (req._ops)
    {
    case '+':
        resp._result = req._x + req._y;
        break;
    case '-':
        resp._result = req._x - req._y;
        break;
    case '*':
        resp._result = req._x * req._y;
        break;
    case '%':
    {
        if(req._y == 0)
        {
            resp._exitCode = -1;//取模错误
            break;
        }
        resp._result = req._x % req._y;//取模是可以操作负数的
        break;
    }
    case '/':
    {
        if(req._y == 0)
        {
            resp._exitCode = -2;//除0错误
            break;
        }
        resp._result = req._x / req._y;//取模是可以操作负数的
        break;
    }
    default:
        resp._exitCode = -3;//操作符非法
        break;
    }
 
    return resp;
}

我们把这个放到了我们的 Serialization.hpp

接下来就接着修改我们的main.cc好了！

main.cc

#include "tcpserver.hpp"
#include 
#include "Serialization.hpp"
 
void DefaultOmMessage(std::shared_ptr connection_ptr)
{
    std::cout << "上层得到了数据：" << connection_ptr->_inbuffer << std::endl;
    std::string inbuf = connection_ptr->_inbuffer;
    size_t packageLen = inbuf.size();
    //由于我们是使用telnet来测试的所以，我们就不解码了
    /*
    // 3.1.解码和反序列化客户端传来的消息
    std::string package = decode(inbuf, &packageLen); // 解码
    if (packageLen == 0)
    {
        printf("decode err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, packageLen);
        // 报文不完整或有误
    }
    */
 
    Request req;
    bool deStatus = req.deserialize(inbuf); // 使用Request的反序列化，packsge内部各个成员已经有了数值
    if (deStatus)                             // 获取消息反序列化成功
    {
        // 3.2.获取结构化的相应
        Response resp = Caculater(req); // 将计算任务的结果存放到Response里面去
 
        // 3.3.序列化和编码响应
        std::string echoStr;
        resp.serialize(echoStr); // 序列化
 
        //由于我们使用的是telnet来测试的，所以我们不编码了
       // echoStr = encode(echoStr, echoStr.size()); // 编码
 
        // 3.4.写入，发送返回值给输出缓冲区
        connection_ptr->_outbuffer=echoStr;
        std::cout<_outbuffer<_clientip, connection_ptr->_clientport, deStatus);
        return;
    }
 
}
 
int main()
{
    std::unique_ptr svr(new TcpServer(8877, DefaultOmMessage));
    svr->Init();
    svr->Loop();
}

我们测试一下 

可以啊！！！ 接下来就是专门处理写事件

3.9.写事件的处理

  之前写服务器时，我们从来没处理过写事件，写事件和读事件不太一样，关心读事件是要常设置的，但写事件一般都是就绪的，因为内核发送缓冲区大概率都是有空间的，如果每次都要让epoll帮我们关心读事件，这其实是一种资源的浪费，因为大部分情况下，你send数据，都是会直接将应用层数据拷贝到内核缓冲区的，不会出现等待的情况，而recv就不太一样，recv在读取的时候，有可能数据还在网络里面，所以recv要等待的概率是比较高的，所以对于读事件来说，常常都要将其设置到sock所关心的事件集合中。

        但写事件并不是这样的，写事件应该是偶尔设置到关心集合中，比如你这次没把数据一次性发完，但你又没设置该sock关心写事件，当下次写事件就绪了，也就是内核发送缓冲区有空间了，epoll_wait也不会通知你，那你还怎么发送剩余数据啊，所以这个时候你就应该设置写事件关心了，让epoll_wait帮你监视sock上的写事件，以便于下次epoll_wait通知你时，你还能够继续发送上次没发完的数据。

        这个时候可能有人会问，ET模式不是只会通知一次吗？如果我这次设置了写关心，但下次发送数据的时候，还是没发送完毕（因为内核发送缓冲区可能没有剩余空间了），那后面ET模式是不是就不会通知我了呀，那我还怎么继续发送剩余的数据呢？ET模式在底层就绪的事件状态发生变化时，还会再通知上层一次的，对于读事件来说，当数据从无到有，从有到多状态发生变化时，ET就还会通知上层一次，对于写事件来说，当内核发送缓冲区剩余空间从无到有，从有到多状态发生变化时，ET也还会通知上层一次，所以不用担心数据发送不完的问题产生，因为ET是会通知我们的。

        在循环外，我们只需要通过判断outbuffer是否为空的情况，来决定是否要设置写事件关心，当数据发送完了那我们就取消对于写事件的关心，不占用epoll的资源，如果数据没发送完，那就设置对于写事件的关心，因为我们要保证下次写事件就绪时，epoll_wait能够通知我们对写事件进行处理。

main.cc

#include "tcpserver.hpp"
#include 
#include "Serialization.hpp"
 
void DefaultOmMessage(std::shared_ptr connection_ptr)
{
    std::cout << "上层得到了数据：" << connection_ptr->_inbuffer << std::endl;
    std::string inbuf = connection_ptr->_inbuffer;
    size_t packageLen = inbuf.size();
    //由于我们是使用telnet来测试的所以，我们就不解码了
    /*
    // 3.1.解码和反序列化客户端传来的消息
    std::string package = decode(inbuf, &packageLen); // 解码
    if (packageLen == 0)
    {
        printf("decode err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, packageLen);
        // 报文不完整或有误
    }
    */
 
    Request req;
    bool deStatus = req.deserialize(inbuf); // 使用Request的反序列化，packsge内部各个成员已经有了数值
    if (deStatus)                             // 获取消息反序列化成功
    {
        // 3.2.获取结构化的相应
        Response resp = Caculater(req); // 将计算任务的结果存放到Response里面去
 
        // 3.3.序列化和编码响应
        std::string echoStr;
        resp.serialize(echoStr); // 序列化
 
        //由于我们使用的是telnet来测试的，所以我们不编码了
       // echoStr = encode(echoStr, echoStr.size()); // 编码
 
        // 3.4.写入，发送返回值给输出缓冲区
        connection_ptr->_outbuffer=echoStr;
        std::cout<_outbuffer<_tcp_server_ptr->Sender(connection_ptr);//调用里面的方法来发送
    }
    else // 客户端消息反序列化失败
    {
        printf("deserialize err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, deStatus);
        return;
    }
    
}

我们注意最后一句，我们直接把发生认为交给了Tcpserver类里的Sender函数，不过这个函数还没有写，我们来写一下！

Tcpserver类里的Sender函数

void Sender(std::shared_ptr connection) // 使用shared_ptr管理Connection对象的生命周期  
{  
    // 无限循环，直到输出缓冲区为空或发生需要退出的错误  
    while (true)  
    {  
        // 引用当前连接的输出缓冲区  
        auto &outbuffer = connection->_outbuffer;  
  
        // 尝试发送数据，send函数返回发送的字节数，或者-1表示错误  
        ssize_t n = send(connection->Getsock(), outbuffer.data(), outbuffer.size(), 0);  
  
        // 如果n大于0，表示部分或全部数据发送成功  
        if (n > 0)  
        {  
            // 从输出缓冲区中移除已发送的数据  
            outbuffer.erase(0, n);  
  
            // 如果输出缓冲区为空，则退出循环  
            if (outbuffer.empty())  
                break;  
        }  
        // 如果n等于0，表示连接已关闭（对端执行了关闭操作），退出函数  
        else if (n == 0)  
        {  
            return;  
        }  
        // 处理发送失败的情况  
        else  
        {  
            // 根据errno的值判断错误类型  
            if (errno == EWOULDBLOCK)  
            {  
                // EWOULDBLOCK表示非阻塞模式下资源暂时不可用，可稍后重试，但这里选择直接退出循环  
                break;  
            }  
            else if (errno == EINTR)  
            {  
                // EINTR表示操作被信号中断，可以安全地重新尝试  
                continue;  
            }  
            else  
            {  
                // 打印错误信息，包含套接字描述符和客户端IP地址及端口  
                std::cout << "sockfd:" << connection->Getsock() << ",client:" << connection->_clientip << ":" << connection->_clientport << "send error" << std::endl;  
  
                // 调用异常处理回调函数  
                Excepter(conection);  
  
                // 退出循环  
                break;  
            }  
        }  
    }  
}

但是这还不够啊，万一我没写完数据呢？我们还需要进行写处理，这里我们就借助epoll机制来帮我们。

// Sender函数负责通过给定的Connection对象发送数据。  
// 它使用epoll机制来管理套接字的读写事件，根据发送情况调整对写事件的关注。  
void Sender(std::shared_ptr connection)  
{  
    // 引用Connection对象的输出缓冲区  
    auto &outbuffer = connection->_outbuffer;  
  
    // 循环发送数据，直到输出缓冲区为空或发生错误  
    while (true)  
    {  
        // 尝试发送数据  
        ssize_t n = send(connection->Getsock(), outbuffer.data(), outbuffer.size(), 0); // 注意：使用.data()获取缓冲区首地址  
  
        // 如果发送成功（n > 0）  
        if (n > 0)  
        {  
            // 从输出缓冲区中移除已发送的数据  
            outbuffer.erase(0, n);  
  
            // 如果输出缓冲区为空，则退出循环  
            if (outbuffer.empty())  
                break;  
        }  
        // 如果n == 0，表示连接已正常关闭（对端调用了close），退出函数  
        else if (n == 0)  
        {  
            return;  
        }  
        // 处理发送失败的情况  
        else  
        {  
            // 检查errno以确定错误类型  
            if (errno == EWOULDBLOCK)  
            {  
                // EWOULDBLOCK表示资源暂时不可用，通常发生在非阻塞模式下，退出循环  
                break;  
            }  
            else if (errno == EINTR)  
            {  
                // EINTR表示操作被信号中断，继续循环尝试发送  
                continue;  
            }  
            else  
            {  
                // 打印错误信息，并调用Connection对象的异常处理回调函数  
                std::cout << "sockfd:" << connection->Getsock() << ",client:" << connection->_clientip << ":" << connection->_clientport << "send error" << std::endl;  
                Excepter(conection);  
                break;  
            }  
        }  
    }  
  
    // 根据输出缓冲区是否为空，调整对写事件的关注  
    if (!outbuffer.empty())  
    {  
        // 如果输出缓冲区不为空，开启对写事件的关注  
        EnableEvent(connection->Getsock(), true, true); // 同时关心读和写事件  
    }  
    else  
    {  
        // 如果输出缓冲区为空，关闭对写事件的关注，但保持对读事件的关注  
        EnableEvent(connection->Getsock(), true, false); // 只关心读事件  
    }  
}  
  
// EnableEvent函数用于根据给定的参数，更新epoll事件监听器对套接字的事件关注。  
void EnableEvent(int sock, bool readable, bool sendable)  
{  
    // 初始化events变量，用于存储要设置的事件标志  
    uint32_t events = 0;  
  
    // 如果需要关注读事件，则设置EPOLLIN标志  
    events |= (readable ? EPOLLIN : 0);  
  
    // 如果需要关注写事件，则设置EPOLLOUT标志  
    events |= (sendable ? EPOLLOUT : 0);  
  
    // 总是设置EPOLLET标志，表示使用边缘触发模式（Edge Triggered）  
    events |= EPOLLET;  
  
    // 调用epoll更新函数，修改对指定套接字的事件关注  
    // 注意：_epoller_ptr应该是一个指向epoll事件监听器对象的指针，EPOLL_CTL_MOD表示修改现有事件  
    _epoller_ptr->EpollUpDate(EPOLL_CTL_MOD, sock, events);  
}

我们测试一下，这能不能完成写的任务啊！

很好，显然是成功了！！！

3.10.异常事件的处理 
        大家仔细看看上面的代码就会知道，读写事件出问题了之后，都是立马将错误和异常都传递给了Exceptrt函数！

        下面是异常事件的处理方法，我们统一对所有异常事件，都先将其从epoll模型中移除，然后关闭文件描述符，最后将conn从哈希表_connecions中移除。

void Excepter(std::shared_ptr conection)
    {
        std::cout << "Execpted ! fd:" << conection->Getsock() << std::endl;
       //1.将文件描述符从epoll模型里面移除来
       _epoller_ptr->EpollUpDate(EPOLL_CTL_DEL,conection->Getsock(),0);
        //2.关闭异常的文件描述符
        close(conection->Getsock());
        //3.从unordered_map中删除
        _connections.erase(conection->Getsock());
 
    }

我们来测试一下：

我们连接我们的服务器，然后退出，服务器就会打印下面这些内容

很显然失败了！

 为什么呢？就是connection指针的生命周期有问题

       值得注意的是，connnection指针指向的连接结构体空间，必须由我们自己释放，有人说，为什么啊？你哈希表不是都已经erase了么？为什么还要程序员自己再delete连接结构体空间呢？

这里要给大家说明一点的是，所有的容器在erase的时候，都只释放容器自己所new出来的空间，像哈希表这样的容器，它会new一个存储键值对的节点空间，节点里面存储着conn指针和sockfd，当调用哈希表的erase时，哈希表只会释放它自己new出来的节点空间，至于这个节点空间里面存储了一个Connection类型的指针，并且这个指针变量指向一个结构体空间，这些事情哈希表才不会管你呢，容器只会释放他自己开辟的空间，哈希表是vector挂单链表的方式来实现的。
所以我们要自己手动释放conn指向的空间，如果你不想自己手动释放conn指向的堆空间资源，则可以存储智能指针对象，这样在哈希表erase时，就会释放智能指针对象的空间，从而自动调用Connection类的析构函数。

  这样搞起来其实还是很麻烦的，所以我们就自己手动释放就好了，如果不手动释放那就会造成内存泄露。

由于实现起来比较麻烦，需要修改代码的很多地方，我就不改了，但是最核心的部分就像下面这样子

 至此，我们的简易版本的单Reactor单进程版本的TCP服务器就算完成了！

3.11.源代码

tcpserver.hpp

#pragma once
#include 
#include 
#include 
#include 
#include 
 
#include "Socket.hpp"
#include "Epoller.hpp"
#include "nocopy.hpp"
#include 
#include 
 
class Connection;
using func_t = std::function)>;
class TcpServer;
 
class Connection
{
public:
    Connection(int sock, std::shared_ptr tcp_server_ptr) : _sock(sock), _tcp_server_ptr(tcp_server_ptr)
    {
    }
    ~Connection()
    {
    }
    void setcallback(func_t recv_cb, func_t send_cb, func_t except_cb)
    {
        _recv_cb = recv_cb;
        _send_cb = send_cb;
        _except_cb = except_cb;
    }
    int Getsock()
    {
        return _sock;
    }
    void Append(std::string info)
    {
        _inbuffer += info;
    }
 
public:
    int _sock;
    std::string _inbuffer; // 这里来当输入缓冲区，但是这里是有缺点的，它不能处理二进制流
    std::string _outbuffer;
 
public:
    func_t _recv_cb;                            // 读回调函数
    func_t _send_cb;                            // 写回调函数
    func_t _except_cb;                          //
    std::shared_ptr _tcp_server_ptr; // 添加一个回指指针
    uint16_t _clientport;
    std::string _clientip;
};
class TcpServer : public nocopy
{
    static const int num = 64;
 
public:
    TcpServer(uint16_t port, func_t OnMessage) : _port(port),
                                                 _listensock_ptr(new Sock()),
                                                 _epoller_ptr(new Epoller()),
                                                 _quit(true),
                                                 _OnMessage(OnMessage)
    {
    }
    ~TcpServer()
    {
    }
    // 设置文件描述符为非阻塞
    int set_non_blocking(int fd)
    {
        int flags = fcntl(fd, F_GETFL, 0);
        if (flags == -1)
        {
            perror("fcntl: get flags");
            return -1;
        }
        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
        {
            perror("fcntl: set non-blocking");
            return -1;
        }
        return 0;
    }
 
    void Init()
    {
        _listensock_ptr->Socket();
        set_non_blocking(_listensock_ptr->Fd()); // 设置listen文件描述符为非阻塞
        _listensock_ptr->Bind(_port);
        _listensock_ptr->Listen();
        AddConnection(_listensock_ptr->Fd(), (EPOLLIN | EPOLLET),
                      std::bind(&TcpServer::Accepter, this, std::placeholders::_1), nullptr, nullptr); // 暂时设置成nullptr
    }
    // 连接管理器
    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sock = accept(conection->Getsock(), (sockaddr *)&peer, &len);
            if (sock > 0)
            {
                // 获取客户端信息
                uint16_t clientport = ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET, &(peer.sin_addr), buffer, sizeof(buffer));
                std::cout << "get a new client from:" << buffer << conection->Getsock() << std::endl;
 
                set_non_blocking(sock); // 设置非阻塞
                AddConnection(sock, EPOLLIN,
                              std::bind(&TcpServer::Recver, this, std::placeholders::_1),
                              std::bind(&TcpServer::Sender, this, std::placeholders::_1),
                              std::bind(&TcpServer::Excepter, this, std::placeholders::_1),
                              buffer, clientport);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                    break;
            }
        }
    }
    // 事件管理器
    void Recver(std::shared_ptr conection)
    {
        int sock = conection->Getsock();
        while (1)
        {
            char buffer[128];
            memset(buffer, 0, sizeof(buffer));
            ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 非阻塞读取
            if (n > 0)                                             // 成功了！！
            {
                conection->Append(buffer); // 把读取的数据放到Connection对象的输入缓冲区里面
            }
            else if (n == 0) // 客户端
            {
                std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "quit" << std::endl;
                Excepter(conection);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                {
                    std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "recv err" << std::endl;
                    Excepter(conection);
                }
            }
            _OnMessage(conection); // 将读取的数据交给上层处理
        }
    }
    void Sender(std::shared_ptr conection)
    {
        std::string outbuffer = conection->_outbuffer;
        while (1)
        {
 
            ssize_t n = send(conection->Getsock(), outbuffer.data(), outbuffer.size(), 0);
            if (n > 0) // 发成功了
            {
                outbuffer.erase(0, n);
                if (outbuffer.empty())
                    break;
            }
            else if (n == 0)
            {
                return;
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    continue;
                else
                {
                    std::cout << "sockfd:" << conection->Getsock() << ",client:" << conection->_clientip << ":" << conection->_clientport << "send error" << std::endl;
                    Excepter(conection);
                    break;
                }
            }
        }
        if (!outbuffer.empty())
        {
            // 开启对写事件的关心
            EnableEvent(conection->Getsock(), true, true); // 关心读写
        }
        else
        {
            // 关闭对写事件的关心
            EnableEvent(conection->Getsock(), true, false); // 关心读,不关心写
        }
    }
    void EnableEvent(int sock, bool readable, bool sendable)
    {
        uint32_t events = 0;
        events |= (readable ? EPOLLIN : 0) | (sendable ? EPOLLOUT : 0) | EPOLLET;
        _epoller_ptr->EpollUpDate(EPOLL_CTL_MOD, sock, events);
    }
    void Excepter(std::shared_ptr conection)
    {
        if (!conection)
        {
            // Connection 对象可能已被销毁，无需进一步操作
            std::cout << "Connection already destroyed, no further action taken." << std::endl;
            return;
        }
 
        std::cout << "Execpted ! fd:" << conection->Getsock() << std::endl;
        // 1.将文件描述符从epoll模型里面移除来
        _epoller_ptr->EpollUpDate(EPOLL_CTL_DEL, conection->Getsock(), 0);
        // 2.关闭异常的文件描述符
        close(conection->Getsock());
        // 3.从unordered_map中删除
        _connections.erase(conection->Getsock());
    }
    void PrintConnection()
    {
        std::cout << "_connections fd list: ";
        for (auto &connection : _connections)
        {
            std::cout << connection.second->Getsock() << " ";
            std::cout << connection.second->_inbuffer;
        }
        std::cout << std::endl;
    }
    void AddConnection(int sock, uint32_t event, func_t recv_cb, func_t send_cb, func_t except_cb,
                       std::string clientip = "0.0.0.0", uint16_t clientport = 0)
    {
 
        // 1.给listen套接字创建一个Connection对象
        std::shared_ptr new_connection = std::make_shared(sock, std::shared_ptr(this)); // 创建Connection对象
        new_connection->setcallback(recv_cb, send_cb, except_cb);
        new_connection->_clientip = clientip;
        new_connection->_clientport = clientport;
 
        // 2.添加到_connections里面去
        _connections.insert(std::make_pair(sock, new_connection));
 
        // 将listen套接字添加到epoll中->将listensock和他关心的事件，添加到内核的epoll模型中的红黑树里面
        // 3.将listensock添加到红黑树
        _epoller_ptr->EpollUpDate(EPOLL_CTL_ADD, sock, event); // 注意这里的EPOLLET设置了ET模式
 
        std::cout << "add a new connection success,sockfd:" << sock << std::endl;
    }
    bool IsConnectionSafe(int fd)
    {
        auto iter = _connections.find(fd);
        if (iter == _connections.end())
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    void Dispatcher() // 事件派发器
    {
        int n = _epoller_ptr->EpollerWait(revs, num); // 获取已经就绪的事件
        for (int i = 0; i < num; i++)
        {
            uint32_t events = revs[i].events;
            int sock = revs[i].data.fd;
            // 如果出现异常，统一转发为读写问题，只需要处理读写就行
            if (events & EPOLLERR) // 出现错误了
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            if (events & EPOLLHUP)
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            // 只需要处理读写就行
            if (events & EPOLLIN && IsConnectionSafe(sock)) // 读事件就绪
            {
                if (_connections[sock]->_recv_cb)
                    _connections[sock]->_recv_cb(_connections[sock]);
            }
            if (events & EPOLLOUT && IsConnectionSafe(sock)) // 写事件就绪
            {
                if (_connections[sock]->_send_cb)
                    _connections[sock]->_send_cb(_connections[sock]);
            }
        }
    }
    void Loop()
    {
        _quit = false;
 
        while (!_quit)
        {
            Dispatcher();
            PrintConnection();
        }
        _quit = true;
    }
 
private:
    uint16_t _port;
    std::shared_ptr _epoller_ptr;
    std::unordered_map> _connections;
    std::shared_ptr _listensock_ptr;
    bool _quit;
    struct epoll_event revs[num]; // 专门用来处理事件的
 
    // 上层处理数据
    func_t _OnMessage; // 将数据交给上层
};

Epoller.hpp

v#pragma once
 
#include 
#include 
#include 
#include 
#include "nocopy.hpp"
 
class Epoller : public nocopy
{
    static const int size = 128;
 
public:
    Epoller()
    {
        _epfd = epoll_create(size);
        if (_epfd == -1)
        {
            perror("epoll_creat error");
        }
        else
        {
            printf("epoll_creat successful:%d
", _epfd);
        }
    }
    ~Epoller()
    {
        if (_epfd > 0)
        {
            close(_epfd);
        }
    }
 
    int EpollerWait(struct epoll_event revents[],int num)
    {
        int n=epoll_wait(_epfd,revents,num,3000);
        return n;
    }
 
    int EpollUpDate(int oper,int sock,uint16_t event)
    {
        int n;
        if(oper==EPOLL_CTL_DEL)//将该事件从epoll红黑树里面删除
        {
            n=epoll_ctl(_epfd,oper,sock,nullptr);
             if(n!=0)
            {
                printf("delete epoll_ctl error");
            }
        }
        else{//添加和修改,即EPOLL_CTL_MOD和EPOLL_CTL_ADD
            struct epoll_event ev;
            ev.events=event;
            ev.data.fd=sock;//方便我们知道是哪个fd就绪了
 
            n=epoll_ctl(_epfd,oper,sock,&ev);
            if(n!=0)
            {
                perror("add epoll_ctl error");
            }
        }
        return n;
    }
 
private:
    int _epfd;
};

nocopy.hpp

#pragma once  
  
class nocopy  
{  
public:  
    // 允许使用默认构造函数（由编译器自动生成）  
    nocopy() = default;   
  
    // 禁用拷贝构造函数，防止通过拷贝来创建类的实例  
    nocopy(const nocopy&) = delete;   
  
    // 禁用赋值运算符，防止类的实例之间通过赋值操作进行内容复制  
    nocopy& operator=(const nocopy&) = delete;   
};

Serialization.hpp

#pragma
#define CRLF "	"               // 分隔符
#define CRLF_LEN strlen(CRLF)   // 分隔符长度
#define SPACE " "               // 空格
#define SPACE_LEN strlen(SPACE) // 空格长度
#define OPS "+-*/%"             // 运算符
 
#include 
#include 
#include 
#include
 
//参数len为in的长度，是一个输出型参数。如果为0代表err
std::string decode(std::string& in,size_t*len)
{
    assert(len);//如果长度为0是错误的
    
    // 1.确认in的序列化字符串完整（分隔符）
    *len=0;
 
    size_t pos = in.find(CRLF);//查找	第一次出现时的下标
    //查找不到，err
    if(pos == std::string::npos){
        return "";//返回空串
    }
   
    // 2.有分隔符，判断长度是否达标
    // 此时pos下标正好就是标识大小的字符长度
    std::string inLenStr = in.substr(0,pos);//从下标0开始一直截取到第一个	之前
 
    //到这里我们要明白，我们这上面截取的是最开头的长度，也就是说，我们截取到的一定是个数字，这个是我们序列化字符的长度
    
    size_t inLen = atoi(inLenStr.c_str());//把截取的这个字符串转int，inLen就是序列化字符的长度
 
    //传入的字符串的长度 - 第一个	前面的字符数 - 2个	
    size_t left = in.size() - inLenStr.size()- 2*CRLF_LEN;//原本预计的序列化字符串长度
    if(left

#include "tcpserver.hpp"
#include 
#include "Serialization.hpp"
 
void DefaultOmMessage(std::shared_ptr connection_ptr)
{
    std::cout << "上层得到了数据：" << connection_ptr->_inbuffer << std::endl;
    std::string inbuf = connection_ptr->_inbuffer;
    size_t packageLen = inbuf.size();
    //由于我们是使用telnet来测试的所以，我们就不解码了
    /*
    // 3.1.解码和反序列化客户端传来的消息
    std::string package = decode(inbuf, &packageLen); // 解码
    if (packageLen == 0)
    {
        printf("decode err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, packageLen);
        // 报文不完整或有误
    }
    */
 
    Request req;
    bool deStatus = req.deserialize(inbuf); // 使用Request的反序列化，packsge内部各个成员已经有了数值
    if (deStatus)                             // 获取消息反序列化成功
    {
        // 3.2.获取结构化的相应
        Response resp = Caculater(req); // 将计算任务的结果存放到Response里面去
 
        // 3.3.序列化和编码响应
        std::string echoStr;
        resp.serialize(echoStr); // 序列化
 
        //由于我们使用的是telnet来测试的，所以我们不编码了
       // echoStr = encode(echoStr, echoStr.size()); // 编码
 
        // 3.4.写入，发送返回值给输出缓冲区
        connection_ptr->_outbuffer=echoStr;
        std::cout<_outbuffer<_tcp_server_ptr->Sender(connection_ptr);//调用里面的方法来发送
    }
    else // 客户端消息反序列化失败
    {
        printf("deserialize err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, deStatus);
        return;
    }
    
}
 
int main()
{
    std::unique_ptr svr(new TcpServer(8877, DefaultOmMessage));
    svr->Init();
    svr->Loop();
}