在虚拟宇宙中低语——进程间通信，Linux命名管道的前世今生

news2025/7/23 22:51:25

文章目录

  • 🌌 序章
  • 🌠 一、命名管道的宿命与哲学
    • 1.1、创建及简单使用
    • 1.2、命名管道的工作原理
    • 1.3、命名管道与匿名管道的区别
  • 2、命名管道的特点及特殊场景
    • 2.1、特点
    • 2.2、四种特殊场景
  • 3、命名管道实操
    • 3.1、实现文件拷贝
    • 3.2、实现进程控制
  • 小结

在这里插入图片描述

🌌 序章

在操作系统的寂静星辰之间，进程如宇宙中的恒星各自运转，孤独却不懈。而在某一刻，它们渴望对话，渴望将彼此的思想穿越内存的风暴，投递至彼此心中。于是，进程间通信（IPC）如星际信使般诞生。而在众多信使中，有一种古老而优雅的方式被称为：命名管道（Named Pipe，亦称FIFO）。

这便是我们今天的主角——在系统的寂静深处低语的“命名管道”。

🌠 一、命名管道的宿命与哲学

命名管道，是一种半双工通信机制，允许两个不具亲缘关系的进程通过内核中一个具名的管道文件进行通信。

正如信使需要地址，命名管道也需栖身于文件系统中，等待两端的进程将心语倾诉或倾听。

与匿名管道（pipe)不同，命名管道拥有一个路径名，存在于文件系统中，通常通过命令 mkfifo 或系统调用mkfifo()创建。即便通信双方毫无血缘（非父子进程），只要知晓这路径，便能互通心声。

那么如何给 匿名管道 起名字呢？

结合文件系统，给匿名管道这个纯纯的内存文件分配 inode，将文件名与之构建联系，关键点在于不给它分配 Data block，因为它是一个纯纯的内存文件，是不需要将数据刷盘到磁盘中的
可以将命名管道理解为 “挂名” 后的匿名管道，把匿名管道加入文件系统中，但仅仅是挂个名而已，目的就是为了让其他进程也能看到这个文件（文件系统中的文件可以被所有进程看到）

因为没有 Data block，所以命名管道这个特殊文件大小为 0

1.1、创建及简单使用

命令管道的创建依赖于函数 mkfifo，函数原型如下
在这里插入图片描述

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

关于 mkfifo 函数

在这里插入图片描述

  • 对于参数1，既可以传递绝对路径 /home/xxx/namePipeCode/fifo，也可以传递相对路径 ./fifo，当然绝对路径更灵活，但也更长

  • 对于参数2，mode_t 其实就是对 unsigned int 的封装，等价于 uint32_t，而 mode 就是创建命名管道时的初始权限，实际权限需要经过 umask 掩码计算

不难发现，mkfifo 和 mkdir 非常像，其实 mkfifo 可以直接在命令行中运行

创建一个名为fifo的命名管道文件

mkfifo fifo

在这里插入图片描述
p是管道文件，大小为0

在这里插入图片描述
这个管道文件也非常特殊：大小为 0，从侧面说明 管道文件就是一个纯纯的内存级文件，有自己的上限，出现在文件系统中，只是单纯挂个名而已

可以直接在命令行中使用命名管道：

  • echo 可以进行数据写入，可以重定向至 fifo
  • cat 可以进行数据读取，同样也可以重定向于 fifo

打开两个终端窗口（两个进程），即可进行通信
在这里插入图片描述
命名管道遵循管道的四种场景，因此在写端未写入数据时，读端会阻塞
当然也可以通过程序实现两个独立进程 IPC

思路：创建 服务端 server 和 客户端 client 两个独立的进程，服务端 server 创建并以 读 的方式打开管道文件，客户端 client 以 写 的方式打开管道文件，打开后俩进程可以进程通信，通信结束后，由客户端关闭 写端（服务端 读端 读取到 0 后也关闭并删除命令管道文件）

注意：

  • 当管道文件不存在时，文件会打开失败，因此为了确保正常通信，需要先运行服务端 server 创建管道文件
  • 服务端启动后，因为是读端，所以会阻塞等待 客户端（写端）写入数据
  • 客户端写入数据时，因为 ‘\n’ 也被读取了，所以要去除此字符
  • 通信结束后，需要服务端主动删除管道文件
unlink 命令管道文件名	//删除管道文件

为了让服务端和客户端能享有同一个文件名，可以创建一个公共头文件 common.h，其中存储 命名管道文件名及默认权限等公有信息

公共资源 common.h

#pragma once

#include <iostream>
#include <string>

std::string fifo_name = "./fifo";   //管道名
uint32_t mode = 0666;   //权限

服务端（写端） server.cc 提供文件拷贝服务

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 服务端
    // 1、打开文件
    int wfd = open(fifo_name.c_str(), O_WRONLY);
    if (wfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、打开源文件
    FILE *fp = fopen("file.txt", "r");
    if (fp == NULL)
    {
        cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、读取源文件数据
    char buff[1024];
    int n = fread(buff, sizeof(char), sizeof(buff), fp);

    //IPC区域
    // 4、写入源文件至命名管道
    write(wfd, buff, strlen(buff));
    cout << "服务端已向管道写入: " << n << "字节的数据" << endl;
    //IPC区域

    fclose(fp);
    fp = nullptr;
    close(wfd);
    return 0;
}

客户端（读端） client.cc 从服务端中拷贝文件（下载）

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 客户端
    // 1、创建命名管道文件
    int ret = mkfifo(fifo_name.c_str(), mode);
    if (ret < 0)
    {
        cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、以读的方式打开管道文件
    int rfd = open(fifo_name.c_str(), O_RDONLY);
    if (rfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、打开目标文件
    FILE *fp = fopen("target.txt", "w");
    if (fp == NULL)
    {
        cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    //IPC区域
    // 4、读取数据
    char buff[1024];
    int n = read(rfd, buff, sizeof(buff) - 1);
    buff[n] = '\0';

    if (n > 0)
        cout << "客户端已从管道读取: " << n << "字节的数据" << endl;
    else if (n == 0)
        cout << "写端关闭，读端读取到0，终止读端" << endl;
    else
        cout << "读取异常" << endl;
    //IPC区域

    //5、写入目标文件，完成拷贝
    fwrite(buff, sizeof(char), strlen(buff), fp);
    cout << "客户端已成功从服务端下载（拷贝）了文件数据" << endl;

    fclose(fp);
    close(rfd);
    unlink(fifo_name.c_str()); // 删除命名管道文件
    return 0;
}

注：strcasecmp 是一个字符串比较函数，无论字符串大小写，都能进行比较

所以 挂了名之后的命名管道是如何实现独立进程间 IPC 的呢？

1.2、命名管道的工作原理

把视角拉回文件系统：当重复多次打开同一个文件时，并不会费力的打开多次，而且在第一次打开的基础上，对struct file结构体中的引用计数 ++，所以对于同一个文件，不同进程打开了，看到的就是同一个

具体例子：显示器文件（stdout）只有一个吧，是不是所有进程都可以同时进行写入？
同理，命名管道文件也是如此，先创建出文件，在文件系统中挂个名，然后让独立的进程以不同的方式打开同一个命名管道文件，比如进程 A 以只读的方式打开，进程 B 以只写的方式打开，那么此时进程 B 就可以向进程 A 写文件，即 IPC
在这里插入图片描述
因为命名管道适用于独立的进程间 IPC，所以无论是读端和写端，进程 A、进程 B 为其分配的 fd 是一致的，都是 3

如果是匿名管道，因为是依靠继承才看到同一文件的，所以读端和写端fd不一样
所以 命名管道 和 匿名管道 还是有区别的

1.3、命名管道与匿名管道的区别

不同点：

  • 匿名管道只能用于具有血缘关系的进程间通信；而命名管道不存在该限制，谁都可以用
  • 匿名管道直接通过pipe函数创建使用；而命名管道需要先通过 mkfifo 函数创建，然后再通过open打开使用
  • 出现多条匿名管道时，可能会出现写端 fd 重复继承的情况；而命名管道不会出现这种情况
  • 在其他方面，匿名管道与命名管道几乎一致

两个都属于管道家族，都是最古老的进程间通信方式，都自带同步与互斥机制，提供的都是流式数据传输

2、命名管道的特点及特殊场景

命名管道的特点及特殊场景与匿名管道完全一致，这里简单回顾下，详细内容可跳转至 《Linux进程间通信【匿名管道】》

2.1、特点

可以简单总结为：

  • 管道是半双工通信
  • 管道生命随进程而终止
  • 命名管道任意多个进程间通信
  • 管道提供的是流式数据传输服务
  • 管道自带 同步与互斥 机制

2.2、四种特殊场景

四种场景分别为

  • 管道为空时，读端阻塞，等待写端写入数据
  • 管道为满时，写端阻塞，等待读端读取数据
  • 进程通信时，关闭读端，OS 发出 13 号信号 SIGPIPE 终止写端进程
  • 进程通信时，关闭写端，读端读取到 0 字节数据，可以借此判断终止读端

3、命名管道实操

以下是一些使用命名管道实现的简单小程序，主要目的是为了熟悉命名管道的使用

3.1、实现文件拷贝

下载应用的本质是在下载文件，将服务器看作写端，自己的电脑看作读端，那么下载这个动作本质上就是 IPC，不过是在网络层面实现的

我们可以利用 命名管道实现不同进程间 IPC，即进程从文件中读取并写入一批数据，另一个进程一次读取一批数据并保存至新文件中，这样就实现了文件的拷贝

目标：利用命名管道，向空文件 target.txt 中写入数据，即拷贝源文件 file.txt

公共资源 common.h

#pragma once

#include <iostream>
#include <string>

std::string fifo_name = "./fifo";   //管道名
uint32_t mode = 0666;   //权限

服务端（写端）server.cc提供文件拷贝服务

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 服务端
    // 1、打开文件
    int wfd = open(fifo_name.c_str(), O_WRONLY);
    if (wfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、打开源文件
    FILE *fp = fopen("file.txt", "r");
    if (fp == NULL)
    {
        cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、读取源文件数据
    char buff[1024];
    int n = fread(buff, sizeof(char), sizeof(buff), fp);

    //IPC区域
    // 4、写入源文件至命名管道
    write(wfd, buff, strlen(buff));
    cout << "服务端已向管道写入: " << n << "字节的数据" << endl;
    //IPC区域

    fclose(fp);
    fp = nullptr;
    close(wfd);
    return 0;
}

客户端（读端）client.cc从服务端中拷贝文件（下载）

#include <iostream>
#include <cstring>
#include <cerrno>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "common.h"

using namespace std;

int main()
{
    // 客户端
    // 1、创建命名管道文件
    int ret = mkfifo(fifo_name.c_str(), mode);
    if (ret < 0)
    {
        cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 2、以读的方式打开管道文件
    int rfd = open(fifo_name.c_str(), O_RDONLY);
    if (rfd < 0)
    {
        cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    // 3、打开目标文件
    FILE *fp = fopen("target.txt", "w");
    if (fp == NULL)
    {
        cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;
        exit(0);
    }

    //IPC区域
    // 4、读取数据
    char buff[1024];
    int n = read(rfd, buff, sizeof(buff) - 1);
    buff[n] = '\0';

    if (n > 0)
        cout << "客户端已从管道读取: " << n << "字节的数据" << endl;
    else if (n == 0)
        cout << "写端关闭，读端读取到0，终止读端" << endl;
    else
        cout << "读取异常" << endl;
    //IPC区域

    //5、写入目标文件，完成拷贝
    fwrite(buff, sizeof(char), strlen(buff), fp);
    cout << "客户端已成功从服务端下载（拷贝）了文件数据" << endl;

    fclose(fp);
    close(rfd);
    unlink(fifo_name.c_str()); // 删除命名管道文件
    return 0;
}

拷贝结果：成功拷贝
在这里插入图片描述
此时 服务端是写端，客户端是读端，实现的是 下载服务；当 服务端是读端，客户端是写端时，实现的就是 上传服务，搞两条管道就能模拟实现简单的 数据双向传输服务

注意： 创建管道文件后，无论先启动读端，还是先启动写端，都要阻塞式的等待另一方进行交互

3.2、实现进程控制

在 Linux 匿名管道 IPC 中，我们实现了一个简易版的进程控制程序，原理是通过多条匿名管道实现父进程对多个子进程执行任务分配

匿名管道用于有血缘关系间 IPC，命名管道也可以

所以我们可以把上一篇文章中的 匿名管道换为命名管道，一样可以实现通信

任务池 Task.hpp

#include <iostream>
#include <string>
#include <functional>
#include <unordered_map>
#include <unistd.h>

using namespace std;

void PrintLOG()
{
    cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}

void InsertSQL()
{
    cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}

void NetRequst()
{
    cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}

class Task
{
public:
    Task()
    {
        // 装载任务
        _tt = {{"打印日志", PrintLOG}, {"数据库插入", InsertSQL}, {"网络请求", NetRequst}};
    }

    // 展示任务
    void showTask()
    {
        cout << "目前可用任务有：[";
        for (auto e : _tt)
            cout << e.first << " ";
        cout << "]" << endl;
        cout << "输入 退出 以终止程序" << endl;
    }

    // 执行任务
    void Execute(const string &task)
    {
        if (_tt.count(task) == 0)
        {
            cerr << "没有这个任务：" << task << endl;
        }
        else
        {
            _tt[task](); // 函数对象调用
        }
    }

private:
    unordered_map<string, function<void(void)>> _tt;
};

控制程序 namePipeCtrl.cc 包括进程、管道创建，任务执行与进程等待

#include <iostream>
#include <string>
#include <vector>
#include <cassert>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "Task.hpp"

using namespace std;

enum
{
    NAME_SIZE = 64
};

// 子进程基本信息类
class ProcINfo
{

public:
    ProcINfo(pid_t pid = pid_t(), int wfd = int())
        : _pid(pid), _wfd(wfd), _num(_cnt++)
    {
        char buff[NAME_SIZE] = {0};
        snprintf(buff, NAME_SIZE, "Process %d | pid:wfd [%d:%d]", _num, _pid, _wfd);
        _name = string(buff);
    }

    pid_t _pid;
    int _wfd;
    int _num;
    string _name;
    static int _cnt;
};

int ProcINfo::_cnt = 0;

// 进程控制类
class ProcCtrl
{
public:
    ProcCtrl(int num = 3, mode_t mode = 0666)
        : _num(num), _mode(mode)
    {
        // 根据 _num 创建命名管道及子进程
        CreatPipeAndProc();
    }

    ~ProcCtrl()
    {
        waitProc();
    }

    // 创建管道及进程
    void CreatPipeAndProc()
    {
        // 因为是继承的，所以也要注意写端重复继承问题
        vector<int> fds;
        for (int i = 0; i < _num; i++)
        {
            // 步骤：创建管道，存入 _vst
            char pipeNameBUff[NAME_SIZE]; // 管道名缓冲区
            snprintf(pipeNameBUff, NAME_SIZE, "./fifo-%d", i);

            int ret = mkfifo(pipeNameBUff, _mode);
            assert(ret != -1);
            (void)ret;

            _vst.push_back(string(pipeNameBUff));

            // 创建子进程，让子进程以只读的方式打开管道文件
            pid_t id = fork();
            if (id == 0)
            {
                // 子进程内
                // 先关闭不必要的写端
                for (auto e : fds)
                    close(e);

                // 打开管道文件，并进入任务等待默认（读端阻塞）
                int rfd = open(_vst[i].c_str(), O_RDONLY);
                assert(rfd != -1);
                (void)rfd;

                waitCommand(rfd);

                close(rfd); // 关闭读端
                exit(0);
            }

            // 父进程以写打开管道，保存 fd 信息
            int wfd = open(_vst[i].c_str(), O_WRONLY);
            assert(wfd != -1);
            (void)wfd;

            // 注册子进程信息
            _vpt.push_back(ProcINfo(id, wfd));
            fds.push_back(wfd);
        }
    }

    // 子进程等待任务派发
    void waitCommand(int rfd)
    {
        while (true)
        {
            char buff[NAME_SIZE] = {0};
            int n = read(rfd, buff, sizeof(buff) - 1);

            buff[n] = '\0';

            if (n > 0)
            {
                Task().Execute(string(buff));
            }
            else if (n == 0)
            {
                cerr << "读端读取到 0，写端已关闭，读端也即将关闭" << endl;
                break;
            }
            else
            {
                cerr << "子进程读取异常！" << endl;
                break;
            }
        }
    }

    // 展示可选进程
    void showProc()
    {
        cout << "目前可用进程有：[";
        int i = 0;
        for (i = 0; i < _num - 1; i++)
            cout << i << "|";
        cout << i << "]" << endl;
    }

    // 下达任务给子进程
    void ctrlProc()
    {
        while (true)
        {
            cout << "==========================" << endl;
            int n = 0;
            do
            {
                showProc();
                cout << "请选择子进程:> ";
                cin >> n;
            } while (n < 0 || n >= _num);

            Task().showTask();
            string taskName;
            cout << "请选择任务:> ";
            cin >> taskName;

            if (taskName == "退出")
                break;

            // 将信息通过命名管道写给子进程
            cout << "选择进程 ->" << _vpt[n]._name << " 执行 " << taskName << " 任务" << endl;
            write(_vpt[n]._wfd, taskName.c_str(), taskName.size());
            sleep(1);
        }
    }

    // 关闭写端、删除文件、等待子进程退出
    void waitProc()
    {
        for (int i = 0; i < _num; i++)
        {
            close(_vpt[i]._wfd);               // 关闭写端
            unlink(_vst[i].c_str());           // 关闭管道文件
            waitpid(_vpt[i]._pid, nullptr, 0); // 等待子进程
        }

        cout << "所有子进程已回收" << endl;
    }

private:
    vector<ProcINfo> _vpt; // 子进程信息表
    vector<string> _vst;   // 命名管道信息表
    int _num;              // 子进程数/命名管道数
    mode_t _mode;          // 命名管道文件的权限
};

int main()
{
    ProcCtrl p1;
    p1.ctrlProc();
    return 0;
}

关于 父子进程间使用命名管道通信 值得注意的问题：

  • 在命名管道创建后，需要先创建子进程，让子进程打开读端或写端，然后才让父进程打开写端或读端，这是因为假如先让父进程打开写端或读端，那么此时父进程就会进入阻塞状态，导致无法创建子进程，自然也就无法再打开【读端或写端】；
  • 所以正确做法是先让子进程打开，即使子进程【阻塞】了，父进程也还能运行。不要让【阻塞】阻碍子进程的创建

子进程继承都存在的问题：写端重复继承，因此需要关闭不必要的写端 fd
关于问题一的理解可以看看下面这两张图：
在这里插入图片描述
正确用法： 先创建子进程，让子进程打开【读端或写端】，再让父进程打开【写端或读端】
在这里插入图片描述

小结

以上就是本次关于 Linux进程间通信之命名管道的全部内容了，作为匿名管道的兄弟，命名管道具备匿名管道的大部分特性，使用方法也基本一致，不过二者在创建和打开方式上各有不同：匿名管道简单，但只能用于具有血缘关系进程间通信，命名管道虽麻烦些，但适用于所有进程间通信场景。

本篇关于命名管道的介绍就暂告段落啦，希望能对大家的学习产生帮助，欢迎各位佬前来支持斧正！！！

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2400658.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

STM32的ADC简介

STM32的ADC简介

一、ADC简介 STM32的ADC是一种12位逐次逼近型模拟数字转换器。它具备18个通道&#xff0c;能够测量16个外部信号源以及2个内部信号源。各通道的A/D转换可以执行单次、连续、扫描或间断模式。转换结果可采用左对齐或右对齐的方式&#xff08;12位&#xff09;存储于16位数据寄存…
阅读更多...
Bash shell四则运算

Bash shell四则运算

文章目录 四则运算1. ‌expr 命令‌2. ‌$(( )) 表达式&#xff08;推荐&#xff09;‌3. ‌$[ ] 表达式&#xff08;已弃用&#xff09;‌4. ‌let 命令‌小数运算i 和 i 区别 四则运算 算术运算&#xff1a; - * / %&#xff08;取模&#xff0c;求余数&#xff09; Bash sh…
阅读更多...
（javaSE）Java数组进阶：数组初始化 数组访问 数组中的jvm 空指针异常

（javaSE）Java数组进阶：数组初始化 数组访问 数组中的jvm 空指针异常

数组的基础 什么是数组呢? 数组指的是一种容器,可以用来存储同种数据类型的多个值 数组的初始化 初始化&#xff1a;就是在内存中,为数组容器开辟空间,并将数据存入容器中的过程。 数组初始化的两种方式&#xff1a;静态初始化&#xff0c;动态初始化 数组的静态初始化 初始化…
阅读更多...
力扣刷题Day 70：在排序数组中查找元素的第一个和最后一个位置（34）

力扣刷题Day 70：在排序数组中查找元素的第一个和最后一个位置（34）

1.题目描述 2.思路 方法1&#xff08;自己写的&#xff09;&#xff1a;一次二分查找找到等于target的一个元素索引axis&#xff0c;然后向左右延伸找边界。 方法2&#xff08;灵茶山艾府佬的闭区间二分查找写法&#xff09;&#xff1a;定义一个lower_bound()函数找到第一个…
阅读更多...
图片压缩工具 | 图片属性详解及读取解析元数据

图片压缩工具 | 图片属性详解及读取解析元数据

ℹ️ 图片信息及属性 基本属性 格式类型&#xff1a;JPEG、PNG、GIF、WEBP、BMP、TIFF等文件大小&#xff1a;以KB、MB等为单位的存储空间占用创建/修改日期&#xff1a;文件的元数据时间戳 视觉属性 尺寸/分辨率 宽度&#xff08;像素&#xff09;高度&#xff08;像素&…
阅读更多...
C# Onnx 动漫人物人脸检测

C# Onnx 动漫人物人脸检测

目录 效果 模型信息 项目 代码 下载 参考 效果 模型信息 Model Properties ------------------------- stride&#xff1a;32 names&#xff1a;{0: face} --------------------------------------------------------------- Inputs ------------------------- name&am…
阅读更多...
C++内存列传之RAII宇宙：智能指针

C++内存列传之RAII宇宙：智能指针

文章目录 1.为什么需要智能指针&#xff1f;2.智能指针原理2.1 RAll2.2 像指针一样使用 3.C11的智能指针3.1 auto_ptr3.2 unique_ptr3.3 shared_ptr3.4 weak_ptr 4.删除器希望读者们多多三连支持小编会继续更新你们的鼓励就是我前进的动力&#xff01; 智能指针是 C 中用于自动…
阅读更多...
PVE 虚拟机安装 Ubuntu Server V24 系统 —— 一步一步安装配置基于 Ubuntu Server 的 NodeJS 服务器详细实录1

PVE 虚拟机安装 Ubuntu Server V24 系统 —— 一步一步安装配置基于 Ubuntu Server 的 NodeJS 服务器详细实录1

前言 最近在基于 NodeJS V22 写一个全栈的项目&#xff0c;写好了&#xff0c;当然需要配置服务器部署啦。这个过程对于熟手来说&#xff0c;还是不复杂的&#xff0c;但是对于很多新手来说&#xff0c;可能稍微有点困难。所以&#xff0c;我把整个过程全部记录一下。 熟悉我…
阅读更多...
TDengine 开发指南——高效写入

TDengine 开发指南——高效写入

高效写入 本章内容将介绍如何发挥 TDengine 最大写入性能&#xff0c;通过原理解析到参数如何配置再到实际示例演示&#xff0c;完整描述如何达到高效写入。 为帮助用户轻松构建百万级吞吐量的数据写入管道&#xff0c;TDengine 连接器提供高效写入的特性。 启动高效写入特性…
阅读更多...
Linux kill 暂停命令

Linux kill 暂停命令

暂停进程 kill -19 在一台服务器上部署了360Pika服务&#xff0c;先用RedisClient连接一下&#xff0c;可以连接 现在暂停进程 暂停后发现再次连接无法连接 恢复进程 kill -18 恢复后可连接
阅读更多...
2.0 阅读方法论与知识总结

2.0 阅读方法论与知识总结

引言 本文将详细分析考研英语阅读做题步骤&#xff0c;并对方法论进行总结&#xff0c;最后通过真题练习巩固方法。 一、做题步骤 所有技巧都建立在精读真题的基础上&#xff01;建议按以下节奏复习&#xff1a; 1️⃣ 做题 先看题干了解文章大致主旨&#xff08;看看有没有…
阅读更多...
5. Qt中.pro文件（1）

5. Qt中.pro文件（1）

本节主要讲.pro文件的作用和一些相关基础知识与操作。 本文部分ppt、视频截图原链接&#xff1a;[萌马工作室的个人空间-萌马工作室个人主页-哔哩哔哩视频] 1 PRO文件 1.1 pro文件作用 添加需要用到的QT模块&#xff0c;如通过QT module_name来添加需要用到的Qt模块。指定生…
阅读更多...
简数采集技巧之快速获取特殊链接网址URL方法

简数采集技巧之快速获取特殊链接网址URL方法

简数采集器列表页提取器的默认配置规则&#xff1a;获取a标签的href属性值作为采集的链接网址&#xff0c;对于大部分网站都是适用的&#xff1b; 但有些网站不使用a标签作为链接跳转&#xff0c;而用javascript的onclick事件替代&#xff0c;那列表页提取器的默认规则将无法获…
阅读更多...
AI 如何改变软件文档生产方式？

AI 如何改变软件文档生产方式？

现代软件工程中的文档革命&#xff1a;从附属品到核心组件的范式升级 在数字化转型浪潮席卷全球的当下&#xff0c;软件系统的复杂度与规模呈现指数级增长。据Gartner最新研究显示&#xff0c;超过67%的企业软件项目延期或超预算的根本原因可追溯至文档系统的缺陷。这一现象在…
阅读更多...
激光干涉仪：解锁协作机器人DD马达的精度密码

激光干涉仪：解锁协作机器人DD马达的精度密码

在工业4.0的浪潮中&#xff0c;协作机器人正以惊人的灵活性重塑生产线——它们与工人并肩作业&#xff0c;精准搬运零件&#xff0c;完成精密装配。还能协同医生完成手术&#xff0c;甚至制作咖啡。 标准的协作机器人关节模组由角度编码器、直驱电机(DD马达)、驱动器、谐波减速…
阅读更多...
HOPE800系列变频器安装到快速调试的详细操作说明

HOPE800系列变频器安装到快速调试的详细操作说明

以下是HOPE800系列变频器从安装到调试的详细操作说明及重要参数设置&#xff0c;适用于工程技术人员或具备电气基础的操作人员。请严格遵循安全规范操作。 以下面电机铭牌为例&#xff1a; HOPE800变频器安装与调试指南** &#xff08;安全第一&#xff01;操作前务必断电并确…
阅读更多...
vCenter与ESXi主机每分钟周期性断连修复

vCenter与ESXi主机每分钟周期性断连修复

问题概述 最近我的测试服务器借给客户用作临时中转&#xff0c;仅更改了ESXi的管理IP&#xff0c;设备拿回来改回原来IP&#xff0c;vCenter开启后重新接收证书&#xff0c;主机和所有VM管理运行正常&#xff0c;跑着跑着发现主机和vCenter会频繁断开连接后又马上自动恢复&…
阅读更多...
web3-区块链困境破解指南：从数字化签名到Rollup 到分片

web3-区块链困境破解指南：从数字化签名到Rollup 到分片

web3-区块链三难困境破解指南&#xff1a;从数字化签名到Rollup 到分片 数字化签名 实体的签名&#xff1a;将交易和签名者绑定在一起 在数字世界的问题是&#xff1a; 任何人都可以从任一文档复制Bob的签名放到自己想放的地方。 解决方案&#xff1a;让签名由文件来决定 b…
阅读更多...
李飞飞World Labs开源革命性Web端3D渲染器Forge！3D高斯溅射技术首次实现全平台流畅运行

李飞飞World Labs开源革命性Web端3D渲染器Forge！3D高斯溅射技术首次实现全平台流畅运行

在AI与3D技术深度融合的今天&#xff0c;李飞飞领衔的World Labs团队再次成为行业焦点。今日&#xff0c;他们正式开源了Forge——一款专为Web端设计的3D高斯溅射&#xff08;3D Gaussian Splatting&#xff09;渲染器&#xff0c;不仅支持THREE.js生态&#xff0c;更能在手机、…
阅读更多...
小鹏汽车5月交付新车33525台 同比增长230%

小鹏汽车5月交付新车33525台 同比增长230%

6月1日&#xff0c;小鹏汽车公布5月交付数据&#xff0c;5月小鹏交付新车33,525台&#xff0c;同比增长230%&#xff0c;与4月交付35,045台相比下降4.3%&#xff0c;已连续7个月交付量突破30,000台。2025年1-5月&#xff0c;小鹏汽车累计交付新车162,578台&#xff0c;同比增长…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023