【Linux】序列化与反序列化

目录

前言

什么是应用层?

再谈"协议"

 什么是序列化和反序列化

网络版计算器

整体流程实现

Sock.hpp的实现

TcpServer.hpp的实现

Protocol.hpp的实现

CalServer.cc的编写

CalClient.cc的编写

整体代码


 

前言

        本章是属于TCP/UDP四层模型中的第一层 应用层相关的内容。主要介绍了序列化与反序列化的应用,本章代码居多,主要是在代码中体现出序列化与反序列化,希望可以耐心阅读,坚持到底一定会有所收获。

什么是应用层?

  • 在网络编程中,应用层是网络协议栈中的最高层。它负责定义网络应用程序与网络通信的接口和规范,主要关注数据的格式、交互方式和应用层协议的定义。

        应用层协议是在应用程序之间进行通信时所使用的规则和约定。它定义了应用程序如何打包、发送、接收和解析数据。应用层协议可以基于不同的传输协议(如TCP、UDP)来提供不同的服务,例如文件传输、电子邮件、网页浏览、即时通信等。

        应用层协议通常在应用程序中实现,为应用程序提供了一组函数、API(例如我们前面使用的socket相关接口)或库,使得应用程序能够通过网络与其他应用程序进行通信。开发者可以使用这些功能来处理数据的编码、解码、发送和接收等操作,同时也可以根据需要定义自己的应用层协议。

        简单来说就是我们程序员写的一个个解决我们实际问题, 满足我们日常需求的网络程序, 都是在应用层.


再谈"协议"

        协议是一种 "约定". socket api的接口, 在读写数据时, 都是按 "字符串" 的方式来发送接收的. 如果我们要传输一些"结构化的数据" 怎么办呢.

        例如, 我们需要实现一个服务器版的加法器. 我们需要客户端把要计算的两个加数发过去, 然后由服务器进行计算, 最后再把结果返回给客户端.

        这里有两种方案:

约定方案一:

  • 客户端发送一个形如"1+1"的字符串;
  • 这个字符串中有两个操作数, 都是整形;
  • 两个数字之间会有一个字符是运算符, 运算符只能是 + ;
  • 数字和运算符之间没有空格;

约定方案二:

  • 定义结构体来表示我们需要交互的信息;
  • 发送数据时将这个结构体按照一个规则转换成字符串, 接收到数据的时候再按照相同的规则把字符串转化回结构体;
  • 这个过程叫做 "序列化" 和 "反序列化"

 什么是序列化和反序列化

        序列化是将内存中的结构化数据(结构体)转换为字节序列的过程。通过序列化,可以将数据结构转换为一系列字节,使其可以被保存到磁盘或通过网络传输。序列化的结果是一个字节流或二进制数据,可以在需要时进行持久化存储或传输给其他系统。

        反序列化是将字节流或二进制数据转换回原始结构化数据(结构体)的过程。通过反序列化,可以将序列化后的数据重新还原为内存中的数据结构,以便在程序中进行处理或使用。

        序列化和反序列化通常用于在分布式系统中进行数据传输、存储和进程间通信。例如,在网络通信中,发送方将数据结构序列化为字节流,通过网络发送给远程主机,然后在远程主机上进行反序列化,以还原数据并进行处理。

【Linux】序列化与反序列化_第1张图片



网络版计算器

整体流程实现

        这个简易版的网络程序是客户端发送类似与“1+2”,“1-2”,“1/2”..,然后服务器返回对应的结果和状态码,代表结果的正确与否。

        我们编写的整体流程是:先对socket接口做封装成Sock类,提供Socket接口,Bind接口,Listen接口,Accept接口以及Connect接口.

        然后我们再对服务器做相关的封装,封装成TcpServer类,构造函数用于初始化服务器,该类对外提供BindService(用于绑定服务)接口,Excute(用来执行对应的回调函数)接口,Start(用于服务器的启动并创建线程运行对应的服务)等接口.

        然后是协议的定制,通信双方(服务端和客户端必须同时遵守这一套规定),共有两个类,分别为Request类和Response类,每个类中分别有两个接口 Serialization(序列化)与Deserialization(反序列化),用于格式的转化。

        最后再分别编写服务端和客户端即可,


Sock.hpp的实现

        这一个文件主要是封装socket的相关接口,到时候我们使用相关socket接口时,只需要调用Sock类中的相关接口即可.

        第一个是Socket函数,封装了socket,并得到一个套接字,将该套接字返回,代码如下:

    int Socket()
    {
        // 1.创建套接字
        int listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "create sock success,  listensock: %d", listensock);
        return listensock;
    }

        第二个是Bind接口,同样地我们首先需要创建一个sockaddr_in结构体,然后填入相关的数据,这个前几章已经说过好多次了,便不再详细说明了,然后调用bind绑定。

    int Bind(int sock, uint16_t port, string ip = "0.0.0.0")
    {
        // 2.bind
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;//使用的协议簇为IPv4
        local.sin_port = htons(port);//填入端口号
        local.sin_addr.s_addr = INADDR_ANY;//填入ip地址

        if (bind(sock, (struct sockaddr *)&local, sizeof local) < 0)
        {
            logMessage(FATAL, "bind error", errno, strerror(errno));
            exit(3);
        }
    }

        第三个是Listen接口,用于对客户端请求的监听,内部只需要调用listen接口并判断即可.

    void Listen(int sock)
    {
        if (listen(sock, gbacklog) < 0)
        {
            logMessage(FATAL, "listen error", errno, strerror(errno));
            exit(3);
        }
        logMessage(NORMAL, "init server success");
    }

        第四个是Accept接口,和上一章所说的一样,先建立一个sockaddr_in结构体,用于接收保存客户端的相关信息(ip和端口等等),同时会得到一个新的套接字,返回这个套接字即可。

    int Accept(int listensock, string *ip, uint16_t *port)
    {
        struct sockaddr_in src;
        socklen_t len = sizeof src;
        int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
        if (servicesock < 0)
        {
            logMessage(ERROR, "accept error", errno, strerror(errno));
            return -1;
        }
        if (port)
            *port = ntohs(src.sin_port);
        if (ip)
            *ip = inet_ntoa(src.sin_addr);
        return servicesock;
    }

        最后一个是Connect接口,和之前的用法一样,先创建一个sockaddr_in结构体,然后填入客户端本身的相关信息,最后调用connect函数接口.

    bool Conncect(int sock,string server_ip, uint16_t server_port)
    {
        struct sockaddr_in server;
        memset(&server,0,sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(server_port);
        server.sin_addr.s_addr=inet_addr(server_ip.c_str());
        
        if(connect(sock,(struct sockaddr*)&server,sizeof server) == 0) return true;
        else {perror("connect"); return false; }
    }

TcpServer.hpp的实现

        这个类中首先要有这3个成员:listensock_用于监听的套接字,Sock sock,上面的Sock类的一个对象,用于接口的调用,vector func_,用于存储相关的服务. func_t是一个函数指针.

定义如下:

   using func_t = function;

        首先是构造函数,需要对服务器进行初始化,包括创建套接字,绑定与监听,如下:

        TcpServer(const uint16_t &port, const string &ip = "0.0.0.0")
        {
            listensock_ = sock_.Socket();
            sock_.Bind(listensock_, port, ip);
            sock_.Listen(listensock_);
        }

        然后是BindService,用于将绑定某一个服务,将其加入到func_即可.

        void BindService(func_t func)
        {
            func_.push_back(func);
        }

        接下来是Excute函数,用于执行func_中的方法:

        void Excute(int sock)
        {
            for(auto & f : func_)
            {
                f(sock);
            }
        }

        然后是Start函数,用于服务器的启动,调用Accept等待客户端的连接,当有客户端连接后,创建一个新的线程,并调用对应的回调函数,于此同时,我们新建一个ThreadData类,用于存储该线程的相关信息,包括该线程的套接字和调用该线程的this指针.如下:

        void Start()
        {
            for (;;)
            {
                string clientip;
                uint16_t clientport;
                int sock = sock_.Accept(listensock_, &clientip, &clientport);
                if (sock == -1)
                    continue;
                logMessage(NORMAL, "Create new link success, sock: %d", sock);

                pthread_t tid;
                ThreadData* td= new ThreadData(sock,this);
                pthread_create(&tid, nullptr, ThreadRoutine, td);
            }
        }

ThreadData类:

    class ThreadData
    {
    public:
        ThreadData(int sock,TcpServer* server):sock_(sock),server_(server)
        {}
        ~ThreadData(){}
    public:
         int sock_;
         TcpServer* server_;
    };

回调函数ThreadRoutine

        static void *ThreadRoutine(void *args)
        {
            pthread_detach(pthread_self());
            ThreadData* td = static_cast(args);
            td->server_->Excute(td->sock_);
            close(td->sock_);

            return nullptr;
        }

Protocol.hpp的实现

        这个类主要是对发送方和应答方进行一个协议的定制,方便发送和解析数据。

所以一共两个类,Request类和Response类.

  • 先来看Request类,即请求方。该类主要是对请求数据的序列化和反序列化.
  • 共有3个类成员:x_,y_,op_,分别代表第一个操作、第二个操作数、和符号.

        第一个接口Serialization序列化,它每次需要把结构化数据转化成字符串形式,我们规定形式为

“x_ op_ y_”,所以代码如下:

        string Serialization()
        {
            // 1.自主实现 "x_ op_ y_\r\n"
            string str;
            str = to_string(x_);
            str += SPACE;
            str += op_;
            str += SPACE;
            str += to_string(y_);
            return str;
        }

        第二个接口是请求方 Deserialization反序列化的实现,需要将字符串数据转化成结构化的数据,首先我们要解析字符串,分别提取出x,y和op,然后赋值给这个类成员(x_,y_,op_),便成功的反序列化了.

        bool Deserialization(const string &str)
        {
            //提取x的第一个字符
            size_t left = str.find(SPACE);
            if (left == string::npos)
                return false;
            //提取y的第一个字符
            size_t right = str.rfind(SPACE);
            if (right == string ::npos)
                return false;
            
            //得到整数x
            x_ = atoi(str.substr(0, left).c_str());
            //得到整数y
            y_ = atoi(str.substr(right + SPACE_LEN).c_str());
            if (left + SPACE_LEN > str.size())
                return false;
            else
                op_ = str[left + SPACE_LEN];
            return true;
        }
  •  Response类

  • 该类主要是对处理结果的序列化和反序列化,类成员有result_和code_,分别代表结果和结果状态码.

它的序列化形式我们规定为“result_ code_”,所以代码如下:

        // code_ result
        string Serialization()
        {
            string s;
            s = to_string(code_);
            s += SPACE;
            s += to_string(result_);
            return s;
        }

反序列化逻辑和Request类一样。分别提取,然后赋值给类成员:

        bool Deserialization(const string& s)
        {
            size_t pos = s.find(SPACE);
            if(pos == string::npos)
            {
                return false;
            }
            code_ = atoi(s.substr(0,pos).c_str());
            result_ = atoi(s.substr(pos+SPACE_LEN).c_str());

            return true;
        }

于此同时,还封装了两个函数,Recv和Send.

实现分别如下:

    string Recv(int sock)
    {
        //tcp是面向字节流的
        char inbuffer[1024];
        ssize_t s = recv(sock, inbuffer, sizeof inbuffer, 0);
        if (s > 0)
        {
            inbuffer[s] = '\0';
            return inbuffer;
        }
        else if(s == 0)
        {
            cout << "client quit" << endl;
        }
        else
        {
            cout << "recv error" << endl;
        }
        return "";
    }
    void Send(int sock, const string str)
    {
        send(sock, str.c_str(), str.size(), 0);
    }

到这里我们基本工作就完成了一大半,接下来是服务端和客户端的编写

CalServer.cc的编写

        这是服务端的代码,首先我们都是要忽略SIGPIPE信号的,这是为了避免进程在写入已关闭的套接字时触发SIGPIPE信号而终止。

        例如,当一个客户端与服务器建立连接后,但在向客户端发送响应前,客户端已经关闭了连接。如果服务器端没有忽略SIGPIPE信号,那么在尝试向已关闭的连接写入数据时,服务器进程将会被终止,这显然是不希望看到的行为。

    signal(SIGPIPE, SIG_IGN);

        然后我们需要绑定一个服务,我们要进行计算,所以假设服务 方法是calculator,该函数首先要从调用Recv读取到请求,如果读取结果不为空的话,我们将读取到的数据进行反序列化成结构化的数据(Request类),然后再将这个结构化的数据传送到calculatorHelp()函数进行计算,再次得到一个结构化的数据(Response类),最后再对这个数据进行序列化成字符串形式,再Send回请求的客户端中.

static Response calculatorHelp(Request &req)
{
    Response resp(0, 0);
    switch (req.op_)
    {
    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.code_ = 1;
        else
            resp.result_ = req.x_ / req.y_;
        break;
    case '%':
        if (req.y_ == 0)
            resp.code_ = 2;
        resp.result_ = req.x_ % req.y_;
        break;
    default:
        resp.code_ = 3;
        break;
    }
    return resp;
}
void calculator(int sock)
{
    while (true)
    {
        string str = Recv(sock); // 在这里我们读到了一个请求
        if (!str.empty())
        {
            Request req;
            req.Deserialization(str); // 反序列化
            Response resp = calculatorHelp(req);
            string respString = resp.Serialization(); // 对计算结果进行序列化
            Send(sock, respString);
        }
        else
        {
            break;
        }
    }
}
int main()
{
    //....
    server->BindService(calculator);
    //....
}

一切完成后,我们在Start启动服务器即可.

    server->Start();

CalClient.cc的编写

        客户端编写就比较简单了,先创建套接字,然后获取到用户输入的ip和port,然后进行Connect,连接完成后,提示用户输入数据,输入完成后,将数据序列化,然后发送给服务器,然后接收服务器返回的数据,再将其反序列化即可。

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }

    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);
    Sock sock;
    int sockfd = sock.Socket();

    cout << sockfd << endl;
    if (!sock.Conncect(sockfd, serverip, serverport))
    {
        cerr << "connect error" << endl;
        exit(2);
    }

    while (true)
    {
        Request req;

        cout << "Please Enter x# ";
        cin >> req.x_;
        cout << "Please Enter y#" ;
        cin >> req.y_;
        cout << "Please Enter operator# ";;
        cin >> req.op_; ;

        string s = req.Serialization();

        Send(sockfd, s);

        string r = Recv(sockfd);
        Response resp;
        resp.Deserialization(r);
        cout << "code: " << resp.code_ << endl;
        cout << "result: " << resp.result_ << endl;

        sleep(1);
    }
    return 0;
}

代码效果图:

 【Linux】序列化与反序列化_第2张图片


 

整体代码

如果你不想仔细看,直接拷贝下面的代码也可以运行,然后可以自己研究:

  • Sock.hpp
#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "log.hpp"

using namespace std;
class Sock
{
public:
    const static int gbacklog = 20;

    Sock(){}
    int Socket()
    {
        // 1.创建套接字
        int listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "create sock success,  listensock: %d", listensock);
        return listensock;
    }
    int Bind(int sock, uint16_t port, string ip = "0.0.0.0")
    {
        // 2.bind
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;//使用的协议簇为IPv4
        local.sin_port = htons(port);//填入端口号
        //local.sin_addr.s_addr = ip.empty() ? INADDR_ANY : inet_addr(ip.c_str());
        local.sin_addr.s_addr = INADDR_ANY;

        if (bind(sock, (struct sockaddr *)&local, sizeof local) < 0)
        {
            logMessage(FATAL, "bind error", errno, strerror(errno));
            exit(3);
        }
    }
    void Listen(int sock)
    {
        // 3.因为TCP是面向连接的,意味着当我们正式通信的时候,需要先建立连接
        if (listen(sock, gbacklog) < 0)
        {
            logMessage(FATAL, "listen error", errno, strerror(errno));
            exit(3);
        }
        logMessage(NORMAL, "init server success");
    }
    // const string& 输入型参数
    // string* 输出型参数
    // string& 输入输出型参数
    int Accept(int listensock, string *ip, uint16_t *port)
    {
        struct sockaddr_in src;
        socklen_t len = sizeof src;
        int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
        if (servicesock < 0)
        {
            logMessage(ERROR, "accept error", errno, strerror(errno));
            return -1;
        }
        if (port)
            *port = ntohs(src.sin_port);
        if (ip)
            *ip = inet_ntoa(src.sin_addr);
        return servicesock;
    }

    bool Conncect(int sock,string server_ip, uint16_t server_port)
    {
        struct sockaddr_in server;
        memset(&server,0,sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(server_port);
        server.sin_addr.s_addr=inet_addr(server_ip.c_str());
        // cout << server.sin_port << " " << server.sin_addr.s_addr << endl;
        if(connect(sock,(struct sockaddr*)&server,sizeof server) == 0) return true;
        else {perror("connect"); return false; }
    }
    ~Sock()
    {
    }

};
  • TcpServer.hpp
​
#pragma once
#include "Sock.hpp"
#include 
#include 
#include 
namespace ns_TcpServer
{
    class TcpServer;
    using func_t = function;
    class ThreadData
    {
    public:
        ThreadData(int sock,TcpServer* server):sock_(sock),server_(server)
        {}
        ~ThreadData(){}
    public:
         int sock_;
         TcpServer* server_;
    };
    class TcpServer
    {
    private:
        static void *ThreadRoutine(void *args)
        {
            pthread_detach(pthread_self());
            ThreadData* td = static_cast(args);
            td->server_->Excute(td->sock_);
            close(td->sock_);

            return nullptr;
        }

    public:
        TcpServer(const uint16_t &port, const string &ip = "0.0.0.0")
        {
            listensock_ = sock_.Socket();
            sock_.Bind(listensock_, port, ip);
            sock_.Listen(listensock_);
        }
        void BindService(func_t func)
        {
            func_.push_back(func);
        }
        void Excute(int sock)
        {
            for(auto & f : func_)
            {
                f(sock);
            }
        }
        void Start()
        {
            for (;;)
            {
                string clientip;
                uint16_t clientport;
                int sock = sock_.Accept(listensock_, &clientip, &clientport);
                if (sock == -1)
                    continue;
                logMessage(NORMAL, "Create new link success, sock: %d", sock);

                pthread_t tid;
                ThreadData* td= new ThreadData(sock,this);
                pthread_create(&tid, nullptr, ThreadRoutine, td);
            }
        }
        ~TcpServer()
        {
            if (listensock_ >= 0)
                close(listensock_);
        }

    private:
        int listensock_;
        Sock sock_;
        vector func_;
    };
}

​
  • Protocol.hpp
#pragma once
#include 
#include 
#include 
#include 
#include 

using namespace std;

namespace ns_protocol
{
#define SPACE " "
#define SPACE_LEN strlen(SPACE)
    class Request
    {
    public:
        string Serialization()
        {
            // 1.自主实现 "x_ op_ y_\r\n"
            string str;
            str = to_string(x_);
            str += SPACE;
            str += op_;
            str += SPACE;
            str += to_string(y_);
            return str;
        }
        bool Deserialization(const string &str)
        {
            size_t left = str.find(SPACE);
            if (left == string::npos)
                return false;
            size_t right = str.rfind(SPACE);
            if (right == string ::npos)
                return false;

            x_ = atoi(str.substr(0, left).c_str());
            y_ = atoi(str.substr(right + SPACE_LEN).c_str());
            if (left + SPACE_LEN > str.size())
                return false;
            else
                op_ = str[left + SPACE_LEN];
            return true;
        }

    public:
        Request(int x, int y, char op) : x_(x), y_(y), op_(op)
        {
        }
        Request()
        {
        }
        ~Request() {}

    public:
        int x_;
        int y_;
        char op_;
    };
    class Response
    {
    public:
        // code_ result
        string Serialization()
        {
            string s;
            s = to_string(code_);
            s += SPACE;
            s += to_string(result_);
            return s;
        }

        bool Deserialization(const string& s)
        {
            size_t pos = s.find(SPACE);
            if(pos == string::npos)
            {
                return false;
            }
            code_ = atoi(s.substr(0,pos).c_str());
            result_ = atoi(s.substr(pos+SPACE_LEN).c_str());

            return true;
        }

    public:
        Response(int res, int code) : result_(result_), code_(code)
        {
        }
        Response()
        {
        }
        ~Response() {}

    public:
        int result_; // 计算结果
        int code_;   // 计算结果状态码
    };
    string Recv(int sock)
    {
        //tcp是面向字节流的

        char inbuffer[1024];
        ssize_t s = recv(sock, inbuffer, sizeof inbuffer, 0);
        if (s > 0)
        {
            inbuffer[s] = '\0';
            return inbuffer;
        }
        else if(s == 0)
        {
            cout << "client quit" << endl;
        }
        else
        {
            cout << "recv error" << endl;
        }
        return "";
    }
    void Send(int sock, const string str)
    {
        send(sock, str.c_str(), str.size(), 0);
    }
}
  • CalServer.cc
#include "TcpServer.hpp"
#include "Protocol.hpp"
#include 
#include 

using namespace ns_TcpServer;
using namespace ns_protocol;
using namespace std;

static void usage(string proc)
{
    cout << "\n Usage: " << proc << "port\n"
         << endl;
}
static Response calculatorHelp(Request &req)
{
    Response resp(0, 0);
    switch (req.op_)
    {
    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.code_ = 1;
        else
            resp.result_ = req.x_ / req.y_;
        break;
    case '%':
        if (req.y_ == 0)
            resp.code_ = 2;
        resp.result_ = req.x_ % req.y_;
        break;
    default:
        resp.code_ = 3;
        break;
    }
    return resp;
}
void calculator(int sock)
{
    while (true)
    {
        string str = Recv(sock); // 在这里我们读到了一个请求
        if (!str.empty())
        {
            Request req;
            req.Deserialization(str); // 反序列化
            Response resp = calculatorHelp(req);
            string respString = resp.Serialization(); // 对计算结果进行序列化
            Send(sock, respString);
        }
        else
        {
            break;
        }
    }
}

//./calServer port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }
    //一般经验:server在编写的时候,要有较为严谨的判断逻辑
    //一般服务器,都是要忽略SIGPIPE信号的,防止在运行中出现非法访问问题
    signal(SIGPIPE, SIG_IGN);
    unique_ptr server(new TcpServer(atoi(argv[1])));
    server->BindService(calculator);
    server->Start();
}
  • CalClient.cc
#include 
#include "Sock.hpp"
#include "Protocol.hpp"
using namespace std;
using namespace ns_protocol;

static void usage(string proc)
{
    cout << "\n Usage: " << proc << " serverIp serverPort\n"
         << endl;
}
//./clinet server_ip server_port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }

    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);
    Sock sock;
    int sockfd = sock.Socket();

    cout << sockfd << endl;
    if (!sock.Conncect(sockfd, serverip, serverport))
    {
        cerr << "connect error" << endl;
        exit(2);
    }

    while (true)
    {
        Request req;
        cout << "Please Enter x# ";
        cin >> req.x_;
        cout << "Please Enter y#" ;
        cin >> req.y_;
        cout << "Please Enter operator# ";;
        cin >> req.op_; 
        string s = req.Serialization();

        Send(sockfd, s);

        string r = Recv(sockfd);
        Response resp;
        resp.Deserialization(r);
        cout << "code: " << resp.code_ << endl;
        cout << "result: " << resp.result_ << endl;

        sleep(1);
    }
    return 0;
}

你可能感兴趣的:(linux,运维,服务器,网络,序列化,反序列化)