网络版本计算器

最新推荐文章于 2024-09-05 14:28:34 发布
最新推荐文章于 2024-09-05 14:28:34 发布
阅读量731 收藏 9
点赞数 10
分类专栏： Linux网络编程 文章标签： linux http tcp/ip 网络协议 vscode vim c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70056514/article/details/136048309
版权

目录

网络版本计算器

1.1 TcpServer.hpp

#pragma once

#include "Protocol.hpp"
#include "Socket.hpp"
#include <functional>
#include "log.hpp"
#include <signal.h>

using func_t = function<string(string &)>;

class TcpServer
{
public:
    TcpServer(const uint16_t &port, func_t callback)
        : _port(port), _callback(callback)
    {
    }
    ~TcpServer()
    {
    }
    bool InitServer()
    {
        // 创建套接字
        _listenSock.Socket();
        int sockfd = _listenSock.Sockfd();

        //设置端口复用
        int opt = 1;
        setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
        
        // 绑定
        _listenSock.Bind(_port);

        // 监听
        _listenSock.Listen();

        log(Info, "Init server successed...");
        return true;
    }
    void Start()
    {
        // 守护进程化
        //参数中的第一个0表示更改该进程的路径为根目录执行，第二个0表示
        //把0，1，2三个文件描述符输出的东西重定向到 /dev/null 文件中
        daemon(0,0);

        // 屏蔽一些信号
        signal(SIGPIPE, SIG_IGN);
        signal(SIGCHLD, SIG_IGN);

        while (true)
        {
            string clientip;
            uint16_t clientport;
            int sockfd = _listenSock.Accept(clientip, clientport);
            if (sockfd > 0)
            {
                if (fork() == 0)
                {
                    // 子进程继承了父进程的监听套接字，但是并用不上，所以可以close掉
                    _listenSock.Close();

                    // 提供服务

                    string inbuffer_stream;
                    while (true)
                    {
                        char tmp[10240];
                        bzero(tmp, sizeof(tmp));
                        ssize_t n = read(sockfd, tmp, sizeof(tmp) - 1);
                        if (n > 0)
                        {
                            tmp[n] = '\0';
                            inbuffer_stream += tmp;
                            cout<<"=========================="<<endl;
                            cout<<inbuffer_stream<<endl;
                            cout<<"=========================="<<endl;

                            string ret;
                            while (true)
                            {
                                //只要返回的不是一个空字符串，就说明请求还没有
                                //处理完，那么就继续处理剩下的请求，把处理结果
                                //存在ret中
                                string str = _callback(inbuffer_stream);
                                if (str.empty())
                                {
                                    break;
                                }
                                ret+=str;
                            }
                            //把请求发送给客户端
                            write(sockfd, ret.c_str(), ret.size());
                        }
                        else if (n == 0)
                        {
                            log(Info, "client exit...");
                            break;
                        }
                        else
                        {
                            log(Fatal, "read failed,errno:%d,errstring:%s", errno, strerror(errno));
                            break;
                        }
                    }
                    close(sockfd);
                    exit(0);
                }

                close(sockfd);
            }
        }
    }

private:
    Sock _listenSock;
    uint16_t _port;
    func_t _callback;
};

1.2 ServerCal.hpp

#pragma once

#include <iostream>
#include "Protocol.hpp"

enum
{
    DivZeroErr,
    ModZeroErr,
    OtherErr
};

class ServerCal
{
public:
    ServerCal()
    {
    }
    ~ServerCal()
    {
    }

    Response CalculatorHelper(const Request &req)
    {
        Response resp(0, 0);
        int x = req._x;
        int y = req._y;
        switch (req._op)
        {
        case '+':
        {
            resp._result = x + y;
            break;
        }
        case '-':
        {
            resp._result = x - y;
            break;
        }
        case '*':
        {
            resp._result = x * y;
            break;
        }
        case '/':
        {
            if (y == 0)
            {
                resp._code = DivZeroErr;
                break;
            }
            resp._result = x / y;
            break;
        }
        case '%':
        {
            if (y == 0)
            {
                resp._code = ModZeroErr;
                break;
            }
            resp._result = x % y;
            break;
        }
        default:
        {
            resp._code = OtherErr;
            break;
        }
        }

        return resp;
    }

    //package: "len"\n"1 + 1"\n
    string Calculator(string& package)
    {
        string content;
        //解码
        bool ret=Decode(package,content);
        if(!ret)
        {
            return "";
        }

        cout<<"///"<<endl;
        cout<<package<<endl;
        cout<<"///"<<endl;
        
        Request req;
        //反序列化
        ret=req.Request_DeSerialize(content);
        if(!ret)
        {
            return "";
        }

        cout<<"get a new task:";
        printf("%d %c %d\n",req._x,req._op,req._y);

        //传入请求，返回响应
        Response resp=CalculatorHelper(req);
        //序列化
        string resp_str=resp.Response_Serialize();
        //添加报头
        Encode(resp_str);

        return resp_str;
    }
};

1.3 ServerCal.cc

#include <iostream>
using namespace std;
#include "ServerCal.hpp"
#include "Protocol.hpp"
#include "TcpServer.hpp"
#include <memory>

// int main()
// {
//     Request req(145,20,'%');
//     string ret=req.Request_Serialize();
//     Encode(ret);
//     cout<<ret<<endl;

//     cout<<endl;
//     Request r;
//     r.Request_DeSerialize(ret);
//     cout<<r._x<<endl;
//     cout<<r._op<<endl;
//     cout<<r._y<<endl;

//     string content;
//     Decode(ret,content);
//     cout<<content<<endl;

//     // Response resp(10,0);
//     // string ret=resp.Response_Serialize();
//     // Encode(ret);
//     // cout<<ret<<endl;

//     // string content;
//     // Decode(ret,content);
//     // cout<<content<<endl;

//     // Response r;
//     // r.Response_DeSerialize(content);
//     // cout<<r._result<<endl;
//     // cout<<r._code<<endl;



//     return 0;
// }


void Usage(string proc)
{
    cout<<"\n\t";
    cout<<"Usage: "<<proc<<" serverPort"<<endl<<endl;
}

//Usage: ./servercal
int main(int argc,char* argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        exit(1);
    }

    uint16_t serverPort=(uint16_t)stoi(argv[1]);
    ServerCal cal;
    //服务器绑定的是Calculator函数，该函数有两个参数，一个绑定为Calculator的this指针，另一个参数自己传
    unique_ptr<TcpServer> svr(new TcpServer(serverPort,bind(&ServerCal::Calculator,&cal,placeholders::_1)));

    //初始化
    svr->InitServer();
    //启动
    svr->Start();

    return 0;
}

1.4 Protocol.hpp

#pragma once
#include <iostream>
using namespace std;
#include "log.hpp"
#include <jsoncpp/json/json.h>

const static string blank_space_sep = " ";
const static string protocol_sep = "\n";

// #define MySelf

extern Log log;

// 添加报头和分隔符
void Encode(string &content)
{
    size_t len = content.size();
    content = to_string(len) + protocol_sep + content + protocol_sep;
}

// 去掉报头,如果解码成功，则继续移除报文，否则，直接返回false
bool Decode(string &package, string &content)
{
    size_t pos = package.find(protocol_sep);

    // 找不到\n不一定是报文的格式错误，也有可能是报文不完整导致的，所以这里
    // 无需打错误日志信息
    if (pos == string::npos)
    {
        // log(Warning, "this package format is failed,package:%s", package.c_str());
        return false;
    }
    string len_str = package.substr(0, pos);
    size_t len = stoi(len_str);
    size_t total_len = len_str.size() + len + 2;
    if (package.size() < total_len)
    {
        log(Warning, "this package format is failed,package:%s", package.c_str());
        return false;
    }

    content = package.substr(pos + 1, len);

    // 解码成功则移除报文
    package.erase(0, total_len);

    return true;
}

class Request
{
public:
    Request()
    {
    }
    Request(int data1, int data2, char oper)
        : _x(data1), _y(data2), _op(oper)
    {
    }
    ~Request()
    {
    }
    // 序列化，即把结构化的数据序列化成字符串
    // 格式："len"\n"x [+-*/%] y"\n
    string Request_Serialize()
    {
#ifdef MySelf
        string content;
        content += to_string(_x);
        content += blank_space_sep;
        content += _op;
        content += blank_space_sep;
        content += to_string(_y);

        return content;
#else
        //用第三方库jsoncpp进行序列化
        //Json::Value是一个key:value的万能对象
        Json::Value root;
        root["x"] = _x;
        root["op"] = _op;
        root["y"] = _y;
        Json::FastWriter w;
        string content = w.write(root);
        return content;
#endif
    }
    // 反序列化
    bool Request_DeSerialize(const string &content_str)
    {
#ifdef MySelf
        size_t left = content_str.find(blank_space_sep);
        if (left == string::npos)
        {
            log(Warning, "this content_str format is failed,content_str:%s", content_str.c_str());
            return false;
        }
        //取出content_str的前半部分
        string left_str = content_str.substr(0, left);

        size_t right = content_str.rfind(blank_space_sep);
        if (right == string::npos)
        {
            log(Warning, "this content_str format is failed,content_str:%s", content_str.c_str());
            return false;
        }
        //取出content_str的后半部分
        string right_str = content_str.substr(right + 1);

        if (left + 2 != right)
        {
            log(Warning, "this content_str format is failed,content_str:%s", content_str.c_str());
            return false;
        }

        _x = stoi(left_str);
        _y = stoi(right_str);
        _op = content_str[left + 1];

        return true;
#else
        //万能对象
        Json::Value v;
        Json::Reader r;
        //把字符串形式的content_str变成结构化的数据，并写到万能对象中去
        r.parse(content_str, v);
        _x = v["x"].asInt();
        _op = v["op"].asInt();
        _y = v["y"].asInt();
        return true;
#endif
    }

public:
    int _x;
    int _y;
    char _op;
};

class Response
{
public:
    Response()
    {
    }
    Response(const int &result, const int &code = 0)
        : _result(result), _code(code)
    {
    }

    ~Response()
    {
    }
    // 格式："len"\n"result code"\n
    string Response_Serialize()
    {
#ifdef MySelf
        string package;
        string result_str = to_string(_result);
        string code_str = to_string(_code);
        size_t body_len = result_str.size() + code_str.size();
        package += result_str;
        package += blank_space_sep;
        package += code_str;

        return package;
#else
        // 万能对象
        Json::Value root;
        root["result"] = _result;
        root["code"] = _code;
        Json::FastWriter w;
        string package = w.write(root);
        return package;
#endif
    }
    bool Response_DeSerialize(const string &content_str)
    {
#ifdef MySelf
        size_t content_left = content_str.find(blank_space_sep);
        if (content_left == string::npos)
        {
            log(Warning, "this content_str format is failed,content_str:%s", content_str.c_str());
            return false;
        }
        string content_left_str = content_str.substr(0, content_left);
        string content_right_str = content_str.substr(content_left + 1);

        _result = stoi(content_left_str);
        _code = stoi(content_right_str);

        return true;
#else
        //Json::Value v是万能对象
        Json::Value v;
        Json::Reader r;
        r.parse(content_str,v);
        _result=v["result"].asInt();
        _code=v["code"].asInt();
        return true;
#endif
    }

public:
    int _result;
    int _code = 0;
};

1.5 Socket.hpp

#pragma once

#include <iostream>
using namespace std;
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "log.hpp"
#include <unistd.h>
#include <strings.h>
#include <cstring>
#include <string>

int backlog = 10;

enum
{
    SockErr = 2,
    BindErr,
    ListenErr,
    ConnectErr,
};

class Sock
{
public:
    Sock()
        : _sockfd(-1)
    {
    }
    ~Sock()
    {
        if(_sockfd>0)
        {
            close(_sockfd);
        }
    }

    // 创建套接字
    void Socket()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            log(Fatal, "socket failed,errno:%d,errstring:%s", errno, strerror(errno));
            exit(SockErr);
        }
        log(Info, "socket successed, sockfd:%d", _sockfd);
    }
    // 绑定
    void Bind(const uint16_t &serverPort)
    {
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(serverPort);
        local.sin_addr.s_addr = INADDR_ANY;

        if (bind(_sockfd, (struct sockaddr *)(&local), sizeof(local)) < 0)
        {
            log(Fatal, "bind failed,errno:%d,errstring:%s", errno, strerror(errno));
            exit(BindErr);
        }
        log(Info, "bind successed...");
    }
    // 监听
    void Listen()
    {
        if (listen(_sockfd, backlog) < 0)
        {
            log(Fatal, "set listen state failed,errno:%d,errstring:%s", errno, strerror(errno));
            exit(ListenErr);
        }
        log(Info, "set listen state successed");
    }
    //获取连接
    int Accept(string& clientip,uint16_t& clientport)
    {
        struct sockaddr_in client;
        socklen_t len=sizeof(client);
        bzero(&client,sizeof(client));

        int sockfd=accept(_sockfd,(struct sockaddr*)(&client),&len);
        if(sockfd<0)
        {
            log(Warning, "accept new link failed,errno:%d,errstring:%s", errno, strerror(errno));
            return -1;
        }
        log(Info,"accept a new link...,sockfd:%d",sockfd);

        clientip=inet_ntoa(client.sin_addr);
        clientport=(uint16_t)(ntohs(client.sin_port));

        return sockfd;
    }
    // 连接
    void Connect(const string &serverIp, const uint16_t &serverPort)
    {
        struct sockaddr_in server;
        bzero(&server, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = inet_addr(serverIp.c_str());
        server.sin_port = htons(serverPort);

        if (connect(_sockfd, (struct sockaddr *)(&server), sizeof(server)) < 0)
        {
            log(Fatal, "connect server failed,errno:%d,errstring:%s", errno, strerror(errno));
            exit(ConnectErr);
        }
        log(Info, "connect server succeeded...");
    }

    void Close()
    {
        if(_sockfd>0)
        {
            close(_sockfd);
        }
    }

    int Sockfd()
    {
        return _sockfd;
    }

private:
    int _sockfd;
};

1.6 makefile

.PHONY:all
all:servercal clientcal

servercal:ServerCal.cc
	g++ -o $@ $^ -std=c++11 -ljsoncpp
clientcal:ClientCal.cc
	g++ -o $@ $^ -std=c++11 -ljsoncpp


.PHONY:clean
clean:
	rm -f clientcal servercal

1.7 ClientCal.cc

#include <iostream>
using namespace std;
#include "Socket.hpp"
#include "Protocol.hpp"
#include <ctime>

void Usage(string proc)
{
    cout << "\n\t";
    cout << "Usage: " << proc << " serverip serverPort" << endl
         << endl;
}

// Usage: ./servercal
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }

    srand(time(nullptr));

    string serverIp = argv[1];
    uint16_t serverPort = (uint16_t)stoi(argv[2]);

    // 创建套接字
    Sock sock;
    sock.Socket();

    // 连接
    sock.Connect(serverIp, serverPort);

    string oper = "+-*/%&^$@#";

    int sockfd = sock.Sockfd();

    string package;
    while (true)
    {
        int x = rand() % 100 + 1;
        int y = rand() % 100;
        char op = oper[rand() % oper.size()];

        //构建请求
        Request req(x, y, op);
        //序列化
        string req_str = req.Request_Serialize();
        cout << "req:" << req_str << endl;
        //添加报头
        Encode(req_str);
        cout << "这是最新的需要发到网络上去的报文：" << endl;
        cout << req_str << endl;

        write(sockfd, req_str.c_str(), req_str.size());

        char buffer[10240];
        bzero(buffer, sizeof(buffer));
        int n = read(sockfd, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            buffer[n] = '\0';
            package += buffer;

            while (true)
            {
                string content;
                Response resp;
                //解码
                bool ret = Decode(package, content);
                if(!ret)
                {
                    //如果解码失败，说明package出问题了或者package中的
                    //内容不是一个完整的报文，跳出本层循环
                    break;
                }

                //来到这里说明解码成功
                cout << content << endl;
                //反序列化
                resp.Response_DeSerialize(content);

                cout << "len : " << content.size() << endl;
                cout << "resp._result : " << resp._result << endl;
                cout << "resp._code : " << resp._code << endl;
            }
        }
        else if (n == 0)
        {
            cout << "server quit..." << endl;
            break;
        }
        else
        {
            perror("read failed");
            break;
        }

        sleep(10);
    }

    sock.Close();

    return 0;
}

1.8 log.hpp

#pragma once

#include <iostream>
using namespace std;
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <string>
#include <time.h>
#include <stdarg.h>

// 日志等级
#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4

#define Screen 1
#define OneFile 2
//向多个文件打印
#define Classfile 3
#define SIZE 1024

#define LogFile "log.txt"



class Log
{
public:
    Log()
    {
        printMethod = Screen;
        path = "./log/";
    }

    void Enable(int mothod)
    {
        printMethod = mothod;
    }

    string LevelToString(int level)
    {
        switch (level)
        {
        case Info:
        {
            return "Info";
        }
        case Debug:
        {
            return "Debug";
        }
        case Warning:
        {
            return "Warning";
        }
        case Error:
        {
            return "Error";
        }
        case Fatal:
        {
            return "Fatal";
        }
        default:
        {
            return "None";
        }
        }
    }

    void printlog(int level,const string& logtxt)
    {
        switch(printMethod)
        {
        case Screen:
        {
            cout<<logtxt<<endl;
            break;
        }
        case OneFile:
        {
            PrintOneFile(LogFile,logtxt);
            break;
        }
        case Classfile:
        {
            PrintClassfile(level,logtxt);
            break;
        }
        default:
        {
            break;
        }
        }
    }

    void PrintOneFile(const string& logname,const string& logtxt)
    {
        string _logname=path+logname;
        int fd=open(_logname.c_str(),O_WRONLY|O_CREAT|O_APPEND,0666);
        if(fd<0)
        {
            perror("open fail");
            return;
        }

        write(fd,logtxt.c_str(),logtxt.size());

        close(fd);

    }

    void PrintClassfile(int level,const string& logtxt)
    {
        string filename=LogFile;
        filename+='.';
        filename+=LevelToString(level);
        PrintOneFile(filename,logtxt);
    }

    void operator()(int level,const char* format,...)
    {
        time_t t=time(nullptr);
        struct tm* ctime=localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer,SIZE,"[%s][%d-%d-%d %d:%d:%d]",LevelToString(level).c_str(),
        ctime->tm_year+1900,ctime->tm_mon+1,ctime->tm_mday,
        ctime->tm_hour,ctime->tm_min,ctime->tm_sec);

        va_list s;
        va_start(s,format);
        char rightbuffer[SIZE]={0};
        vsnprintf(rightbuffer,SIZE,format,s);
        va_end(s);


        char logtxt[SIZE*2];
        snprintf(logtxt,sizeof(logtxt),"%s %s",leftbuffer,rightbuffer);

        printlog(level,logtxt);
    }

    ~Log()
    {
    }

private:
    // 打印方法
    int printMethod;
    string path;
};

//定义一个全局的log
Log log;

以上就是关于网络版本计算器的全部实现过程了，你学会了吗？如果感觉到有所收获的话，就点点赞点点关注呗，后期还会持续更新网络编程的相关知识哦，我们下期见！！！

Gay~
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
频点换算计算器android,LTE频率频点计算器
weixin_39693950的博客
06-01 1949
LTE频率频点计算器是一个简单实用的频率频点计算工具，输入下行频、输入频段、输入频率和频段，频点计算频率、频率计算频点频段查询等。。相关软件软件大小版本说明下载地址LTE频率频点计算器是一个简单实用的频率频点计算工具，输入下行频、输入频段、输入频率和频段，频点计算频率、频率计算频点频段查询等。常见问题LTE有什么特性？LTE中的很多标准接手于3G UMTS的更新并最后成为4G移动通信技术。其中简化...
网络计算器
02-17
在这个名为"Web-Calculator-main"的项目中，我们可以推测这是一个网络计算器应用的源代码仓库。以下是一些可能包含在该项目中的关键知识点： 1. **HTML 结构**：网络计算器的界面由一系列HTML元素组成，包括按钮、...
网络协议与网络版计算器：深度融合与技术创新
shiming8879的博客
08-09 1178
网络协议是网络通信中双方必须共同遵守的一组约定和规则，它们定义了数据如何封装、寻址、传输、接收以及错误处理等各个环节。常见的网络协议包括TCP/IP协议族、HTTP、FTP、SMTP等，它们各自承担着不同的功能，共同构成了复杂的网络通信体系。TCP/IP协议族：作为互联网的基础协议，TCP（传输控制协议）负责数据的可靠传输，通过三次握手建立连接，确保数据包的顺序和完整性；IP（互联网协议）则负责数据的寻址和路由，将数据包从源地址发送到目的地址。HTTP（超文本传输协议）
【网络】协议与网络版计算器
Chujun123528的博客
08-09 898
网络协议是网络通信中双方或多方必须遵循的一系列规则和标准，它们规定了数据交换的格式、顺序、速率以及控制信息的结构和含义。没有统一的协议，不同设备之间就无法进行有效的通信。网络协议的存在，使得全球范围内的计算机能够相互连接，共享资源，实现信息的快速传递。网络版计算器作为网络应用的一个简单实例，不仅展示了网络服务的实现方式，也深刻体现了网络协议在其中的关键作用。从物理层到应用层，每一层协议都为实现计算器服务提供了必要的支持和保障。同时，在设计和实现过程中，还需要考虑安全性、性能优化、扩展性和可维护性等多个方面。
【Linux Network】网络版计算器
qq_52842680的博客
05-12 729
网络版计算器的制作
Windows 多功能计算器
暗诺星刻的博客
01-19 3046
Windows 多功能计算器版本 M.3.1 运行效果图基本信息开发环境编程语言技术内幕架构模式设计模式模块介绍包名介绍测试核心算法操作数运算算法表达式检查的算法静态检查与动态检查算法单个字符语法检查的算法【静态检查算法】表达式计算的算法【动态检查算法】显示计算过程的算法通信算法独出心裁的设计将 Map 当做 Redis 数据库来使用懒执行JavaFX 与 Spring 适配使用 URL 来方便地进行各 UI 组件的之间的交互旧算法操作数运算算法（旧版本 M.1.1）显示计算过程的算法（旧版本 M.1.2）
网络和Linux网络_4(应用层)序列化和反序列化(网络计算器)
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-22 1411
网络和Linux网络_4（应用层）序列化和反序列化（网络版本计算器+守护进程+Json的使用，再理解了协议）协议的重新理解+计算器完整代码，下一篇：应用层_HTTP协议（方法+报头+状态码）。
手机图形计算器matlab,科学图形计算器 Mathlab
weixin_36410141的博客
03-25 666
如果你正在寻找一个使用流畅、天衣无缝的图形计算器应用程序，恭喜你，你已经找到了！Mathlab发行的图形计算器是一款非常科学的集成代数图形计算器，是中小学生和大学生研究生，以及任何有复杂计算需求者必不可少的计算工具。设计这款软件的目的是取代笨重而昂贵的手持式计算器，并适用于几乎所有的安卓手机或平板电脑。此外，Mathlab发行的图形计算器应用于安卓设备的高品质显示屏上，对用户来说，计算更加清晰易懂...
GitHub分享的微软开源计算器项目
不脱发的程序猿
03-10 6805
微软在 MIT License 下开源了一个 GitHub 项目——Windows 计算器，短短 24 小时内就获得了接近 5000 颗星，并引发大量讨论。这个项目爆红的速度可能连微软自己都始料未及。科技媒体 The Verge 评价道，「虽然计算器只是 Windows 的一个很小的部分，但开源计算器这一事件延续了微软近年来拥抱开源的作风」 开源地址：https://github.com/Mic...
用python编计算器_python编计算器
weixin_39652646的博客
11-29 1445
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！功能说明：使用python编写一个计算器，实现简单的加减乘除功能。 程序的逻辑很简单，取出括号，计算里面的乘除加减，结果替换原括号内容，再循环直到最终结果。 难点在于正则匹配字符和计算细节上，怎么很好协调配合并正确获得结果。 逻辑图：? 程序目录：main.py ###程序入口che...
java ip子网计算器_ip子网计算器IPV4子网计算工具v1.1
weixin_42298969的博客
02-24 1456
网络已经普及，IPV4地址已经耗尽，IPV6时代已经到来，部分城市已经商用，快盘小编提供的这个工具仅仅适用于IPV4网络的掩码计算器。不管是IPV4还是v6时代，每一个网络工程师都知道ip地址，掩码，网关这些概念。但并不是所有的网络管理员都能牢记这些掩码是如何计算了，给出一段地址马上就能口算出来掩码，网络号等等这些。但是现在有了这款工具，再也不用担心那些少于24位掩码号的计算了。对于小编来说。大于...
PersonaQFusionCalculator:Persona Q 的网络融合计算器
06-27
"PersonaQFusionCalculator" 是一个专为 Persona Q 设计的网络融合计算器，它简化了计算和预测 Persona 融合结果的过程，让玩家可以更高效地规划他们的队伍构成。 这个计算器是基于 JavaScript 开发的，JavaScript ...
衰减网络计算器
07-01
衰减网络计算器是一种专门针对高频硬件领域的调试计算工具，它在射频（RF）工程中起着至关重要的作用。在无线通信、雷达系统、卫星通信等应用中，信号的衰减是一个不可忽视的因素，需要精确计算以确保信号传输的质量...
机顶盒-网络盒子-中兴-adb密码计算器（5/6位密码）
02-01
描述中提到，“中兴机顶盒网络盒子，adb调试模式所需密码计算器软件，安卓版本应用，apk安装包。”这表明该软件是一个Android应用程序，以APK文件形式提供，用于计算开启ADB调试模式所需的密码。APK是Android应用的...
TCP/IP网络编程：Linux实现的web服务器
weixin_57112913的博客
09-05 777
这是客户端向服务端发送的请求消息的结构，Web服务器需要解析并响应客户端请求，从图中看出，请求信息包含请求行，消息头，消息体等三个部分，这里我们只对GET类型的进行撰写，具体的含义是：“请求（GET）index/html文件，希望以1.1版本的HTTP协议进行通信”例如，客户端请求 index.html 文件时，表示 index.html 文件是否存在、服务端是否发生问题而无法响应等不同情况的信息写入状态行。状态行中有关于请求的状态信息，这是与请求消息相比最为显著地区别。200 OK : 成功处理了请求!
Linux文本处理大纲
最新发布
kimi_DikQ的博客
09-05 301
x > 10 判断变量x是否大于10。x >= 10 大于等于。x <= 10 小于等于。
Linux 命令行快捷键
sun007700的专栏
08-30 691
涉及在linux命令行下进行快速移动光标、命令编辑、编辑后执行历史命令、Bang(!Ctrl+y: 粘贴Ctrl+u或ctrl+k剪切的内容。Alt – d ：由光标位置开始，往右删除单词。Alt – d: 先按住 Alt 键，然后再按 d 键；Ctrl+u：删除当前光标前面的文字 (还有剪切功能)Ctrl+k：删除当前光标后面的文字 (还有剪切功能)M – k：先单击 Esc 键，然后再按 k 键。Ctrl+w: 删除光标前面的单词。Ctrl+左右键:在单词之间跳转。Ctrl+a: 跳到本行的行首。
【Linux】08.Linux 下的第一个小程序——进度条
caryon的博客
09-02 552
对换行与回车的直观解释，认识缓冲区，编写小程序
Linux C 内核编程 /proc 编程例子
yong1585855343的博客
09-02 390
Linux 内核编程 /proc 例子代码
网络编程计算器mfc编码
07-11
网络编程计算器通常是指使用Microsoft Foundation Class (MFC)框架开发的一款应用程序，它允许用户通过网络连接来进行计算操作。MFC是微软提供的一套Windows应用程序开发工具包，它可以简化C++编程并加快开发速度。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值