网络版本计算器

最新推荐文章于 2024-09-19 00:10:40 发布
最新推荐文章于 2024-09-19 00:10:40 发布
阅读量737 收藏 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~
关注
专栏目录
网络计算器
02-17
在这个名为"Web-Calculator-main"的项目中，我们可以推测这是一个网络计算器应用的源代码仓库。以下是一些可能包含在该项目中的关键知识点： 1. **HTML 结构**：网络计算器的界面由一系列HTML元素组成，包括按钮、...
基于webservice的网络计算器
11-28
【基于Webservice的网络计算器】是一种利用Web服务技术实现的在线计算工具，它允许用户通过互联网进行各种数学运算。在WEBGIS（Web地理信息系统）课程中，这种计算器可能被用作一个实例，来帮助学生理解如何将Web...
衰减网络计算器
07-01
衰减网络计算器是一种专门针对高频硬件领域的调试计算工具，它在射频（RF）工程中起着至关重要的作用。在无线通信、雷达系统、卫星通信等应用中，信号的衰减是一个不可忽视的因素，需要精确计算以确保信号传输的质量...
基于Android的计算器
10-14
它提供了代码编辑、调试、性能优化和版本控制等功能。对于初学者，熟悉其界面和基本操作是至关重要的。 2. **Activity和Intent**: Activity是Android应用的基本构建块，代表用户与应用交互的屏幕。在这个计算器应用...
【Linux】uImage头部信息详细解析
W__winter的博客
09-16 1520
【代码】【Linux】uImage头部信息详细解析。
【Linux】：信号与信号产生
Yikefore的博客
09-12 1017
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
Linux Vim编辑器常用命令
最新发布
Calvin的博客
09-19 178
命令模式快捷键 编辑/输入模式快捷键 编辑模式切换到命令模式
linux-进程管理-进程查看与控制
Flying_Fish_roe的博客
09-18 487
进程是操作系统中执行中的程序。Linux 将每个运行的程序看作是一个进程，每个进程都有唯一的进程ID (PID)。在 Linux 系统中，进程管理是非常重要的，它能够帮助系统管理员和用户查看、管理、优化系统资源的使用情况。Linux 提供了丰富的命令来查看和控制进程，例如pstophtopkill等等。这些命令允许用户监控和控制系统中运行的进程，以确保系统资源的合理使用，并避免进程阻塞或占用过多资源。在 Linux 系统中，进程管理是非常关键的操作。通过使用pstophtop。
【网络安全】服务基础第二阶段——第五节：Linux系统管理基础----Linux常见应用服务（Apache、数据库）
goldfish8848的博客
09-12 1258
在Linux系统中，有许多常见的应用服务，它们用于执行各种任务，如网页托管、数据库管理、文件传输等。
【在Linux世界中追寻伟大的One Piece】五种IO模型和阻塞IO
weixin_74809706的博客
09-12 1478
高级IO涉及到文件的IO操作，它包括多种技术，如非阻塞IO、记录锁、IO多路转接、异步IO和存储映射等。这些技术通常依赖于文件描述符(fd)和fcntl函数的支持，用于提高文件IO操作的效率和灵活性。
Linux3-cp,mv,rm,*
2301_80339607的博客
09-15 297
复制文件：cp test1.txt test2.txt，把当前目录下的test1.txt文件复制一份到当前目录下，并命名为text.txt。例如cp -r test1 test2，把当前目录下的test1文件夹复制一份到当前目录下，并命名为text2。强制删除：选项-f(force)，普通用户用不到，root用户使用，所以如果要使用需要先切换为root用户。(在test目录下)删除文件夹：带选项-r，例如rm -r test2。(在test1目录下)删除文件：rm test3.txt。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 1113
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
对目录的操作、获取文件信息
2303_80050865的博客
09-15 405
4）关于目录分隔符号，在windows下 "/ " 和 "//" 都可以，比如如"d://aaa//bbb//hi.txt"和"d:/aaa/bbb/hi.txt"，linux/unix是"/",比如 /root/home/aa.log 因此建议目录分隔符，为了兼容，linux和windows都使用"/"2）f.close()：刷新并关闭此流，也就是f.close()内置的flush功能。3）删除目录 d://aaa和d://bbb//ccc。2）创建多级目录 d://bbb//ccc。
linux实用操作
lonelyxxyo的博客
09-13 1710
环境变量PATH这个项目里面记录了系统执行命令的搜索路径。这些搜索路径我们也可以自行添加到PATH中去。黑马教学案例：测试：在当前HOME目录内创建文件夹，myenv，在文件夹内创建文件mkhaha通过vim编辑器，在mkhaha文件内填入：echo 哈哈哈哈哈完成上述操作后，随意切换工作目录，执行mkhaha命令尝试一下，会发现无法执行修改PATH的值。
linux 中删除乱码中文名文件
她的吻让他
09-13 305
在操作linux时会不经意将带有中文的文件发送到linux系统,但是有些linux系统不能识别中文以及中文符号等,会导致linux shell命令无法操作这些文件。想要删除无法识别名字的文件,需要找到其inode 号,通过inode 删除文件。find . -inum inode号 -exec rm {} \;整体操作分为两条指令。
从零开始学习Linux（12）---进程间通信（信号量与信号）
lys20221113242的博客
09-16 795
信号是操作系统提供的让用户（进程）给其他进程发送异步信息的一种方式，Linux定义了一系列的信号，每个信号都有一个唯一的编号和一个默认的行为。在并发编程中，当多个进程或线程需要访问共享资源时，信号量用来确保资源在同一时刻只被一个进程或线程访问，从而避免竞争条件。：如果信号量的值大于零，则将其减一；否则，进程或线程会被阻塞，直到信号量值变为正。：信号量是一个非负整数，用来表示可用的资源的数量。：其值可以是任何非负整数，用于表示资源的可用数量。：增加信号量的值，并唤醒等待的进程或线程。
一个linux下监听某个端口并拉起任务的shell脚本
唯有热爱 可抵万难
09-12 425
注意替换脚本和日志为自己的 绝对路径的文件。替换为你创建的监控脚本的文件名。
Linux 之 Nginx 下载/安装
sszdzq的博客
09-12 531
nginx 的解压目录与编译目录（默认：/usr/local/nginx）不能是一个。1.下载 nginx-1.26.2.tar.gz 并上传到 /usr/local。3. 指定相关配置--编译--安装。nginx.repo 文件内容。
linux下lvm（逻辑卷管理器）
蓝色海洋-探寻
09-13 865
lvm
网络编程计算器mfc编码
07-11
网络编程计算器通常是指使用Microsoft Foundation Class (MFC)框架开发的一款应用程序，它允许用户通过网络连接来进行计算操作。MFC是微软提供的一套Windows应用程序开发工具包，它可以简化C++编程并加快开发速度。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值