网络版计算器

最新推荐文章于 2024-09-30 17:57:44 发布
最新推荐文章于 2024-09-30 17:57:44 发布
阅读量461 收藏 2
点赞数 1
分类专栏： Linux 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64028711/article/details/131753145
版权

        本次我们实现一个服务器版本的简单的计算器，通过自己在应用层定制协议来将数据传输出去。

协议代码

        此处我们为了解耦，采用了两个类，分别表示客户端的请求和服务端的响应。

Request
class Request
{
public:
    Request()
    {
    }
    Request(int x, int y, char op)
        : _x(x), _y(y), _op(op)
    {
    }

    // 序列化
    bool serialize(string &out)
    {
        out += to_string(_x);
        out += SEP;
        out += _op;
        out += SEP;
        out += to_string(_y);
        return true;
    }
    // 反序列化 x + y
    bool deserialize(const string &in)
    {
        string x_str, y_str;
        int left = in.find(SEP);
        if (left == string::npos)
            return false;

        int right = in.rfind(SEP);
        if (right == string::npos)
            return false;

        x_str = in.substr(0, left);
        y_str = in.substr(right + 1);
        _x = stoi(x_str);
        _y = stoi(y_str);
        _op = in[left + SEP_LEN];
        return true;
    }

    int _x;
    int _y;
    char _op;
};
Response
class Response
{
public:
    Response()
        : exitcode(0), result(0)
    {
    }
    // 序列化
    bool serialize(string &out)
    {
        out.clear();
        out += to_string(exitcode);
        out += SEP;
        out += to_string(result);
    }
    // 反序列化
    bool deserialize(const string &in)
    {
        // exitcode result
        string exit_str, result_str;
        int pos = in.find(SEP);

        if (pos == string::npos)
            return false;

        exit_str = in.substr(0, pos);
        result_str = in.substr(pos + SEP_LEN);
        if (exit_str.empty() || result_str.empty())
            return false;

        exitcode = stoi(exit_str);
        result = stoi(result_str);
    }

    int exitcode;
    int result;
};

        而对于两个类来说，它们最重要的就是序列化和反序列化的过程。

        对于请求类，它需要将所输入的数据序列化转化成为字符串，转化的字符串就是一整个报文，便于后续添加报头；而它的反序列化就需要将报文重新转化为数据，便于后续的计算任务进行。

        对于响应类，它需要将所得到的结果序列化转化为字符串；反序列化则是将报文转化为数据。

        当数据序列化后就需要添加报头，而反序列化的任务则需要在去除报头后进行。

添加和去除报头

#define SEP " "
#define SEP_LEN strlen(SEP)
#define SEP_LINE "\\r\\n"
#define SEP_LINE_LEN strlen(SEP_LINE)

// 报头格式 text_len/r/ntext/r/n
// 添加报头

bool Enlength(const string &in, string &out)
{
    out.clear();
    out += to_string(in.size());
    out += SEP_LINE;
    out += in;
    out += SEP_LINE;
    return true;
}
// 去掉报头
// 去掉后 只剩 text
bool Delength(const string &in, string &out)
{
    int pos = in.find(SEP_LINE);
    if (pos == string::npos)
        return false;
    int text_len = stoi(in.substr(0, pos));
    out = in.substr(pos + SEP_LINE_LEN, text_len);
    return true;
}

        此处我们的报头的格式就是 "text_len\r\ntext\r\n" 的格式。 

        这Enlength函数可以将报文转化为数据包，Delength可以将数据包转化为报文。

 接收函数

// 接收的是一个数据 是 text_len/r/ntext/r/n的形式
bool Recv(int socket, string &inbuffer, string &pacakge)
{
    char buffer[1024];
    while (true)
    {
        int n = recv(socket, buffer, sizeof(buffer) - 1, 0);
        if (n > 0)
        {
            // 开始接收
            buffer[n] = 0;
            inbuffer += buffer;
            int pos = inbuffer.find(SEP_LINE);
            if (pos == string::npos)
                continue;
            int text_len = stoi(inbuffer.substr(0, pos));
            string len_string = inbuffer.substr(0, pos);
            int total_len = text_len + len_string.size() + SEP_LINE_LEN * 2;
            if (inbuffer.size() < total_len)
                continue; // 说明没有一个完整的报文

            // 此时就说明至少有一个完整的报文
            pacakge = inbuffer.substr(0, total_len + 1);
            inbuffer.erase(total_len);

            break;
        }
        else
        {
            return false;
        }
    }
    return true;
}

        此外，由于TCP是字节流的协议，我们需要自定义函数来保证收到了至少一个完整的报文。 

计算函数 

void CalHandler(const Request &rq, Response &rp)
{
    switch (rq._op)
    {
    case '+':
        rp.result = rq._x + rq._y;
        break;
    case '-':
        rp.result = rq._x - rq._y;
        break;
    case '*':
        rp.result = rq._x * rq._y;
        break;
    case '/':
        if (rq._y == 0)
        {
            rp.exitcode = 1;
        }
        else
        {
            rp.result = rq._x / rq._y;
        }
        break;
    case '%':
        if (rq._y == 0)
        {
            rp.exitcode = 1;
        }
        else
        {
            rp.result = rq._x % rq._y;
        }
        break;
    }
}

服务器

        首先直接看看服务器的代码。

calsever.hpp

#include <iostream>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include "protocol.hpp"

using namespace std;

#define gbacklog 5

class Sever;

class Sever
{
public:
    Sever(const uint16_t &port)
        : _port(port), _listensocket(-1)
    {
    }

    void InitSever()
    {
        _listensocket = socket(AF_INET, SOCK_STREAM, 0); // TCP是面向字节流的协议

        // bind该socket
        struct sockaddr_in peer;
        peer.sin_family = AF_INET;
        peer.sin_port = htons(_port);
        peer.sin_addr.s_addr = INADDR_ANY;
        if (bind(_listensocket, (sockaddr *)&peer, sizeof(peer)) < 0)
        {
            cout << "bind err!" << endl;
            exit(-1);
        }
        cout << "bind success!" << endl;

        // 监听该socket
        if (listen(_listensocket, gbacklog) < 0)
        {
            cout << "listen err!" << endl;
            exit(-1);
        }
        cout << "listen success!" << endl;
    }

    void start()
    {
        while (true)
        {
            struct sockaddr_in peer;
            bzero(&peer, sizeof(peer));
            socklen_t len = sizeof(peer);
            int socket = accept(_listensocket, (sockaddr *)&peer, &len);

            if (socket < 0)
            {
                cout << "socket err" << endl;
                exit(-1);
            }

            cout << "accept success socket : " << socket << endl;

            // version 2.1 多进程版
            pid_t id = fork();
            if (id == 0) // 子进程内部
            {
                close(_listensocket); // 子进程不用监听，父进程监听即可
                if (fork() > 0)
                    exit(-1); // 直接让子进程创建孙子进程，然后将子进程退出，让孙子进程被领养
                handlerEnter(socket);
                close(socket);

            } // 但是父进程不用等待，否则会造成串行
        }
    }

    void handlerEnter(int socket)
    {
        string inbuffer;
        while (true)
        {

            // 读取数据
            string recv_text,recv_pacakge;
            while(!Recv(socket,recv_text,recv_pacakge))
            {
            }
            //去报头
            if(!Delength(recv_pacakge,recv_text))
            return;
            Request rq;
            // 反序列化
            if(!rq.deserialize(recv_text))
            {
                return;
            }
            // 计算公式
            Response rp;
            CalHandler(rq,rp);
            // 将结果序列化
            string send_text,send_pacakge;
            rp.serialize(send_text);
            //添加报头
            Enlength(send_text,send_pacakge);
            // 发送结果
            send(socket,send_pacakge.c_str(),send_pacakge.size(),0);
        }
    }

private:
    uint16_t _port;
    int _listensocket;
};

calsever.cc 

#include "calSever.hpp"
#include <memory>

using namespace std;

int main(int args, char *argv[])
{
    if (args != 2) // 在运行时必须带有端口号
    {
        cout << " ./Sever port" << endl;
        exit(-1);
    }

    uint16_t port = atoi(argv[1]);

    unique_ptr<Sever> TCPSever(new Sever(port));
    
    TCPSever->InitSever();
    TCPSever->start();

    return 0;
}

        对于服务器的代码，并没有太大的改动，主要是服务器所需要进行的任务的代码需要了解。

        

         首先是接收客户端发过来的数据，由于此处使用的是TCP协议进行传输，所以可能接受的数据包不是一个完整的数据包，因此需要利用循环和自定义的函数进行检测。

        而该函数的逻辑大致为 接收到数据包——去掉报头——对报文进行反序列化——对获取的数据进行计算——将结果序列化——对报文添加报头——发送数据包。

        整体逻辑十分简单，但前提是函数需要正确使用。

客户端

calclient.hpp

#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <strings.h>
#include <unistd.h>
#include"protocol.hpp"

using namespace std;

class Client
{

public:
    Client(const uint16_t &port, const string &ip)
        : _severport(port), _severip(ip), _socket(-1)
    {
    }

    void InitClient()
    {
        _socket = socket(AF_INET, SOCK_STREAM, 0);
        if (_socket < 0)
        {
            cout << "socket failed" << endl;
        }
    }

    void run()
    {
        struct sockaddr_in peer;
        bzero(&peer, sizeof(peer));
        peer.sin_family = AF_INET;
        peer.sin_port = htons(_severport);
        peer.sin_addr.s_addr = inet_addr(_severip.c_str());

        if (connect(_socket, (sockaddr *)&peer, sizeof(peer)) == -1)
        {
            cout << "connect failed" << endl;
            exit(-1);
        }
        else
        {
            // 输入所需要计算的公式
            string inbuffer;
            while (true)
            {
                int x, y;
                char op;
                cout << "请输入第一个数据 :";
                cin >> x;
                cout << "请输入第二个数据 :";
                cin >> y;
                cout << "请输入计算方式 :";
                cin >> op;

                string send_text,send_pacakge;
                Request rq(x,y,op);

                // 进行序列化以及添加报头
                rq.serialize(send_text);
                Enlength(send_text,send_pacakge);

                // 发送公式
                send(_socket,send_pacakge.c_str(),send_pacakge.size(),0);

                // 接收结果

                string recv_text,recv_pacakge;
                while(!Recv(_socket,inbuffer,recv_pacakge))
                {
                    //若是接收失败就重试
                }

                //此时已经接收到结果
                // 对结果进行反序列化并输出

                Response rp;
                //去掉报头
                Delength(recv_pacakge,recv_text);
                rp.deserialize(recv_text);

                if(rp.exitcode != 0)
                cout<<"err ! exitcode : "<<rp.exitcode<<endl;
                else 
                {
                    cout<<"The result : "<<rp.result<<endl;
                }
            }
        }
    }

private:
    uint16_t _severport;
    string _severip;
    int _socket;
};

calclient.cc

#include"calClient.hpp"
#include<memory>
using namespace std;

void Remind()
{
    cout<<"./Client Severport Severip"<<endl;
}

int main(int args,char* argv[])
{

    if(args!=3)
    {
        Remind();
        exit(-1);
    }

    uint16_t port = atoi(argv[1]);
    string ip = argv[2];

    unique_ptr<Client> TCPClient(new Client(port,ip));

    TCPClient->InitClient();
    TCPClient->run();

    return 0;
}

        对于客户端而言，它的工作和服务器大差不差。 

         具体逻辑是 获取数据——序列化——添加报头——传输数据包——接收数据包——去掉报头——反序列化——获取结果。       

        接下来就来直接看看结果。

        

 

         能看到我们确实成功的运行并计算出结果。

        但是我们可以看到，由我们自己定义协议十分麻烦，这里是协议很小，当我们的项目很大的时候，也许协议就不止这么点了，因此我们有更简单的方法来定制协议。 

更简单的方案：

  • json
  • protobuf
  • xml

json方案的序列化和反序列化 

class Request
{
public:
    Request()
    {
    }
    Request(int x, int y, char op)
        : _x(x), _y(y), _op(op)
    {
    }

    // 序列化
    bool serialize(string &out)
    {
        #ifdef MYSELF
        out += to_string(_x);
        out += SEP;
        out += _op;
        out += SEP;
        out += to_string(_y);
        #else
            Json::Value root;
            root["first"] = _x;
            root["second"] = _y;
            root["operator"] = _op;

            Json::FastWriter w;
            out = w.write(root);  
        #endif
        return true;
    }
    // 反序列化 x + y
    bool deserialize(const string &in)
    {
        #ifdef MYSELF
        string x_str, y_str;
        int left = in.find(SEP);
        if (left == string::npos)
            return false;

        int right = in.rfind(SEP);
        if (right == string::npos)
            return false;

        x_str = in.substr(0, left);
        y_str = in.substr(right + 1);
        _x = stoi(x_str);
        _y = stoi(y_str);
        _op = in[left + SEP_LEN];
        #else 
        Json::Value root;
        Json::Reader r;
        r.parse(in,root);
        _x = root["first"].asInt();
        _y = root["second"].asInt();
        _op = root["operator"].asInt();

        
        #endif
        return true;

    }

    int _x;
    int _y;
    char _op;
};

class Response
{
public:
    Response()
        : exitcode(0), result(0)
    {
    }
    // 序列化
    bool serialize(string &out)
    {
        #ifdef MYSELF
        out.clear();
        out+=to_string(exitcode);
        out+=SEP;
        out+=to_string(result);
        #else 
        Json::Value root;
        root["exitcode"] = exitcode;
        root["result"] = result;
        Json::FastWriter w;
        out = w.write(root);
        #endif  
        return true;
    }
    // 反序列化
    bool deserialize(const string &in)
    {
        #ifdef MYSELF
        //exitcode result
        string exit_str,result_str;
        int pos = in.find(SEP);

        if(pos == string::npos)
            return false;

        exit_str = in.substr(0,pos);
        result_str = in.substr(pos+SEP_LEN);
        if(exit_str.empty()||result_str.empty())
            return false;
        
        exitcode = stoi(exit_str);
        result = stoi(result_str);
        #else
        Json::Value root;
        Json::Reader r;
        r.parse(in,root);
        exitcode = root["exitcode"].asInt();
        result = root["result"].asInt();
 

        #endif
        return true;

    }

    int exitcode;
    int result;
};

         我们能够看到确实成功了。

        不过使用json需要一点小小的准备工作。

  • 下载对应的工具

        可以用root账号或者sudo进行下载。

        yun install -y jsoncpp-devel

        
  •  包含头文件

  •  编译添加新指令

        只要是使用了json的文件，就需要添加 -ljsoncpp 指令才行。

 

 

一般路过半缘君
关注
专栏目录
_Linux (网络版计算器简易实现)
Dingyuan0的博客
02-27 783
网络版计算器简易实现(TCP主要熟悉协议---模拟实现一下自己写的协议方案)。
公式计算器（可自定义公式）
10-31
公式计算器，可自定义公式，方便小巧，操作简单，安全无毒。
【网络版计算器】
weixin_47952981的博客
04-08 268
如果我们需要实现一个服务器版的加法器. 我们需要客户端把要计算的两个加数发过去, 然后由服务器进行计算, 最后再把结果返回给客户端约定方案一:1.客户端发送一个形如"1+1"的字符串;2.这个字符串中有两个操作数, 都是整形;3.两个数字之间会有一个字符是运算符,运算符只能是 +;4.数字和运算符之间没有空格;约定方案二:1.定义结构体来表示我们需要交互的信息;2.发送数据时将这个结构体按照一个规则转换成字符串,接收到数据的时候再按照相同的规则把字符串转化回结构体;
移动应用开发 计算器基本实现
m0_59588838的博客
05-01 1329
本学期的安卓开发学习课程，我们的老师强调自己敲出来点小应用，而不是依赖他的源码学习，所以老师讲过的布局方法以及界面组件和实现组件动作的监听以及对应的响应反馈内容。这一套组合拳打下来，我也基本学会了简单应用的设计与实现，我第一个会的就是计算器，业务逻辑实现的难度不大，可能细节比较多。界面设计目前采用tableLayout布局方法，我觉得gruidlayot布局方法会就更合适，因为比如等于号可能会独占两列，而表格布局难以实现独占两列的情况。至于组件业绩仅有Button这一种组件，可以粘贴复制，因为组件大小基本都
可以编辑自己需要的计算公式的计算器
10-30
能够提高工作效率的计算器，可以编辑自己需要的公式的计算器
基础复习——项目练习——计算器
小白龙白龙马的博客
07-30 2843
布局： <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:background="#eeeeee" ...
网络协议与网络版计算器：深度融合与技术创新
shiming8879的博客
08-09 1206
网络协议是网络通信中双方必须共同遵守的一组约定和规则，它们定义了数据如何封装、寻址、传输、接收以及错误处理等各个环节。常见的网络协议包括TCP/IP协议族、HTTP、FTP、SMTP等，它们各自承担着不同的功能，共同构成了复杂的网络通信体系。TCP/IP协议族：作为互联网的基础协议，TCP（传输控制协议）负责数据的可靠传输，通过三次握手建立连接，确保数据包的顺序和完整性；IP（互联网协议）则负责数据的寻址和路由，将数据包从源地址发送到目的地址。HTTP（超文本传输协议）
【网络】协议与网络版计算器
℉f的博客
08-08 2344
为了使数据在网络上能够从源到达目的，网络通信的参与方必须遵循相同的规则，我们将这套规则称为协议（protocol），而协议最终都需要通过计算机语言的方式表示出来。只有通信计算机双方都遵守相同的协议，计算机之间才能互相通信交流。
Linux——实现一个简单的网络版计算器
今天你AC了吗
05-25 1205
网络版计算器1.程序简介2.思路3.代码实现4.运行结果 1.程序简介 我们想要实现一个服务器版的简易计算器，我们需要从客户端发送两个数据以及所要操作的类型，然后由服务器进行处理，并将结果返回至客户端 2.思路 这种运算的规则，我们也可以认为是一种协议，因为是客户端与服务端达成的某种约定 我们需要定义两个结构体去表示客户端与服务端之间进行交互的信息 发送数据时将这个结构体按照一个规则转换成字符串，接收数据的时候再按照相同的规则把字符串转化为结构体 这个过程就叫做序列化和反序列化 3.代码实现 Ma
【Linux Network】网络版计算器
qq_52842680的博客
05-12 736
网络版计算器的制作
简易版计算器.zip
04-17
【简易版计算器.zip】是一个包含基于JavaScript实现的网络版计算器的压缩文件。这个计算器主要针对网页前端应用，旨在提供基本的计算功能，如加、减、乘、除等。JavaScript是一种广泛使用的编程语言，尤其在网页开发...
子网掩码计算器下载/子网掩码计算器单机版--亲测好用
05-09
子网掩码计算器下载/子网掩码计算器单机版--亲测好用 子网掩码计算器下载/子网掩码计算器单机版--亲测好用 子网掩码计算器下载/子网掩码计算器单机版--亲测好用 子网掩码计算器下载/子网掩码计算器单机版--亲测好用 ...
计算器升级版
07-21
2. **科学计算功能**：传统计算器可能只包含基本的加减乘除运算，而升级版计算器通常会添加更多的科学计算功能，如对数、指数、三角函数、复数运算、阶乘、平方根、立方根等。这些功能对于学生、科学家或者工程师来...
网络计算器
02-28
网络计算器是一种基于Web技术的工具，它允许用户执行各种数学计算而无需下载和安装任何桌面应用程序。这个项目可能是一个开源的HTML项目，名为"web-calculator-master"，它表明我们正在探讨一个用HTML构建的在线...
实现一个服务器版的计算器
qq_37941471的博客
06-23 1563
服务器版的加法器 客户端 ： 我们需要把要计算的两个加数发过去 服务器端 ： 进行计算 方案 ： 方案一： 1. 客户端发送一个例如“1+1”的字符串 2. 这个字符串中有两个操作数，都是整型 3. 两个数字之间有一个字符是运算符, 运算符只能是 + 4. 数字和运算符之间没有空格 ........ 方案二： 1. 定义结构体来表示我们需要发送的信息...
[原]把一个简单计算器做成Web自定义控件
weixin_33816821的博客
06-22 584
这次，我们就继《动态创建Web控件制做计算器》的文章，把Web控件制作的就算器做成一个Web控件，首先，打开vs2005，文件/新建/项目，如下图： 在visual C#中选择Windows 在模版里面选择Web控件库，输入名称和存储位置，点确定。进入代码区以后，删掉默认的Text属性，开始写我们的代码，先修该一些必要的属性，以至于让我们自己做的控件像一个产品。 将控件类名字...
MQTT--EMQX入门+MQTTX使用
最新发布
CJPSR的博客
09-30 925
EMQ X基于 Erlang/OTP 平台开发的MQTT 消息服务器，是开源社区中最流行的 MQTT 消息服务器。EMQ X 是开源百万级分布式。
信息安全对抗演习：应对网络威胁的坚实防线
dexun123的博客
09-29 836
演习结束后，需要对整个演习过程进行总结和评估。分析演习中发现的问题和不足并提出改进措施；同时总结经验教训为未来的演习提供参考。
网络层——IP
weixin_74269833的博客
09-28 1145
由32位二进制数组成，通常用点分的形式被分为四个部分，每个部分1byte，最大值为255。从功能的角度看，ip地址由两部分组成，网络号和主机号。网络号标识了ip所在的网段，主机号标识了在该网段中的唯一的一台主机。二者的区分又需要与掩码配合使用，例如192.168.1.2/24，24表示掩码255.255.255.0，将掩码与ip进行按位与操作，获得了192.168.1.0即为该主机所在网段。将IP地址中的主机地址全部设为0, 就成为了网络号, 代表这个局域网。
网络编程计算器mfc编码
07-11
网络编程计算器通常是指使用Microsoft Foundation Class (MFC)框架开发的一款应用程序，它允许用户通过网络连接来进行计算操作。MFC是微软提供的一套Windows应用程序开发工具包，它可以简化C++编程并加快开发速度。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值