[linux进程控制]进程替换

已于 2023-12-05 22:40:45 修改
阅读量157 收藏
点赞数
分类专栏： Linux从入门到放弃 文章标签： linux 运维 服务器
于 2023-12-03 20:03:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHRan_ran_/article/details/134631372
版权

文章目录

1.进程替换的概念和原理

之前讲过fork()函数的用法:

  1. 一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程不处理客户端请求，生成子
    进程来处理这个请求。
  2. 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。==>进程替换

fork()之后 父子进程各自执行父进程代码的一部分 如果子进程想执行一个另外的/全新的程序要怎么做呢?

本来父子进程共享代码和数据 (数据写时拷贝) 子进程怎么去拥有自己的代码呢?

进程替换完成这个功能: 通过特定的接口 把磁盘上一个全新的程序(代码和数据)加载到子进程的地址空间中

当进程替换后 都会发生什么呢?

  1. 新程序的代码和数据加载到内存
  2. 进程替换并没有创建新的进程 所以该进程的pid并不改变
  3. 原进程即被替换的进程的PCB/进程地址空间/页表没有释放 新程序的PCB/进程地址空间/页表没有被创建 而是将原进程的PCB/进程地址空间/页表的内容完全替换成新程序的PCB/进程地址空间/页表的内容 页表左侧替换成新程序对应的虚拟地址 页表右侧替换成新程序的物理地址
  4. 旧进程的用户空间代码和数据完全被新程序替换 从新程序的启动例程开始执行

如何完成这一系列操作?

操作系统的接口exec函数: 加载新程序代码和数据到内存 建立新的映射关系

2.如何完成进程替换

2.1exec系列函数

加载器的底层系统调用接口

#include <unistd.h>
int execve(const char *filename, char *const argv[], char *const envp[]);

在这里插入图片描述

基于execve的封装–库函数

	   #include <unistd.h>
       extern char **environ;
       
       int execl(const char *path, const char *arg, ...);
       int execlp(const char *file, const char *arg, ...);
       int execle(const char *path, const char *arg, ..., char * const envp[]);
       
       int execv(const char *path, char *const argv[]);
       int execvp(const char *file, char *const argv[]);
       int execvpe(const char *file, char *const argv[], char *const envp[]);

在这里插入图片描述

在这里插入图片描述

命名理解

l(list) : 参数采用列表形式
v(vector) : 参数用数组形式
p(path) : 自动搜索环境变量PATH
e(env) : 自己维护环境变量

2.2 int execl(const char *path, const char *arg, …);

1.在当前进程进行替换

 int execl(const char *path, const char *arg, ...);
 execl: l--list 像结点一样将参数传入可变参数列表
 path: 路径+目标文件名
 arg: 可变参数列表 可以传入多个参数(个数不定)
 调用时: 以NULL结尾 表示参数传递完毕
  1. execl()函数: 函数调用成功后 当前的代码和数据完全被新程序的代码和数据替换
  2. 函数调用失败后会返回-1(执行原代码 对原代码无影响) 表示调用新程序失败 调用成功没有返回值 因为调用成功后当前代码和数据完全被替换 而execl()就在其中

代码演示

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
    printf("当前进程开始运行\n");

    //execl("/usr/bin/ls", "ls", NULL);
    execl("/usr/bin/ls", "ls", "-l", "-a", "-i", NULL);
    //execl("/usr/bin/top", "top", NULL);
    //execl("/usr/bin/ls", "ls", "--color=auto", "-l", NULL);

    ls是一个用C语言写的程序 他也有main函数 实际上 这里的传参就是把参数传给了ls程序里的main函数 这也与我们之前讲到的命令行参数的空间布局相呼应 
    exit(1);
    printf("当前进程结束!\n");
    return 0;
}

在这里插入图片描述

为什么在xshell下执行ls 就会有颜色 而在我们的程序里执行ls 还要加"--color=auto"才会有颜色?

因为在bash进程里给ls取了别名 自动就会加"--color=auto"

2.在子进程进行替换

在子进程进行进程替换的目的

  1. 不影响父进程 让父进程聚焦在读取数据，解析数据，指派子进程执行代码
  2. 让子进程被替换的目的是去执行新的程序而不是执行父进程的不同代码 所以让子进程进行替换的目的就是让父进程仍然执行他自己的代码 让子进程执行一个新的程序 并且父进程不受影响

对子进程进行程序替换的理解

  1. 子进程被替换前 父子进程代码共享 数据写时拷贝
  2. 当子进程发生进程替换 会有一份新的程序(代码+数据)完全覆盖子进程原有内容 此时会发生写时拷贝 即当子进程发生进程替换 子进程在物理内存中将会有自己的单独空间(新程序)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(int argc, char*argv[], char *env[])
{
        pid_t id = fork();
        if(id == 0)
        {
            //子进程
            printf("子进程开始运行, pid: %d\n", getpid());
            sleep(3);
            execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
            exit(1);
        }
        else 
        {
            //父进程
            printf("父进程开始运行, pid: %d\n", getpid());
            int status = 0;
            pid_t id = waitpid(-1, &status, 0);
            if(id > 0)
            {
                printf("wait success, exit code: %d\n", WEXITSTATUS(status));
            }
        }
     return 0;
}

2.3 int execv(const char *path, char *const argv[]);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM 16
int main(int argc, char*argv[], char *env[])
{
        pid_t id = fork();
        if(id == 0)
        {
            //子进程
            printf("子进程开始运行, pid: %d\n", getpid());
            sleep(3);
            char *const _argv[NUM] = {
                (char*)"ls",
                (char*)"-a",
                (char*)"-l",
                (char*)"-i",
                NULL
            };
            //execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
            execv("/usr/bin/ls", _argv);
            exit(1);
        }
        else 
        {
            //父进程
            printf("父进程开始运行, pid: %d\n", getpid());
            int status = 0;
            pid_t id = waitpid(-1, &status, 0); 
            if(id > 0)
            {
                printf("wait success, exit code: %d\n", WEXITSTATUS(status));
            }
        }
    return 0;
}

2.4 int execlp(const char *file, const char *arg, …);

自动在环境变量PATH中查找文件名的路径

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM 16
int main(int argc, char*argv[], char *env[])
{
        pid_t id = fork();
        if(id == 0)
        {
            //子进程
            printf("子进程开始运行, pid: %d\n", getpid());
            sleep(3);
            char *const _argv[NUM] = {
                (char*)"ls",
                (char*)"-a",
                (char*)"-l",
                (char*)"-i",
                NULL
            };
            //execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
            //execv("/usr/bin/ls", _argv); 
            
            execlp("ls", "ls", "-a", "-l", NULL);
            exit(1);
        }
        else 
        {
            //父进程
            printf("父进程开始运行, pid: %d\n", getpid());
            int status = 0;
            pid_t id = waitpid(-1, &status, 0); 
            if(id > 0)
            {
                printf("wait success, exit code: %d\n", WEXITSTATUS(status));
            }
        }
    return 0;
}

2.5 int execvp(const char *file, char *const argv[]);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM 16
int main(int argc, char*argv[], char *env[])
{
        pid_t id = fork();
        if(id == 0)
        {
            //子进程
             printf("子进程开始运行, pid: %d\n", getpid());
            sleep(3);
            char *const _argv[NUM] = {
                (char*)"ls",
                (char*)"-a",
                (char*)"-l",
                (char*)"-i",
                NULL
            };
            //execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
            //execv("/usr/bin/ls", _argv); //和上面的execl只有传参方式的区别
            //execlp("ls", "ls", "-a", "-l", NULL);
            execvp("ls", _argv);
            exit(1);
        }
        else 
        {
            //父进程
            printf("父进程开始运行, pid: %d\n", getpid());
            int status = 0;
            pid_t id = waitpid(-1, &status, 0); 
            if(id > 0)
            {
                printf("wait success, exit code: %d\n", WEXITSTATUS(status));
            }
        }
    return 0;
}

2.6 int execle(const char *path, const char *arg, …, char * const envp[]);

1.Makefile: 一次生成多个可执行程序

在这里插入图片描述

2.子进程中执行自己写的C/C++程序

2.1自己写的C/C++程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("can not execute！\n");
        exit(1);
    }

    if(strcmp(argv[1], "-a") == 0)
    {
        printf("hello a!\n");
    }
    else if(strcmp(argv[1], "-b") == 0)
    {
        printf("hello b!\n");
    }
    else
    {
        printf("default!\n");
    }

    return 0;
}
2.2执行自己写的C/C++程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM 16

//const char *fileaddr = "/home/lhr/linux/procreplace/cmd";
const char *fileaddr = "./cmd";

int main(int argc, char*argv[], char *env[])
{
        pid_t id = fork();
        if(id == 0)
        {
            //子进程
            printf("子进程开始运行, pid: %d\n", getpid());
            sleep(3);
            char *const _argv[NUM] = {
                (char*)"ls",
                (char*)"-a",
                (char*)"-l",
                (char*)"-i",
                NULL
            };
            execle(fileaddr, "cmd", "-a", NULL);
            //execle(fileaddr, "cmd", "-a", NULL);

            //execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
            //execv("/usr/bin/ls", _argv); //和上面的execl只有传参方式的区别
            //execlp("ls", "ls", "-a", "-l", NULL);
            //execvp("ls", _argv);
            exit(1);
        }
        else 
        {
            //父进程
            printf("父进程开始运行, pid: %d\n", getpid());
            int status = 0;
            pid_t id = waitpid(-1, &status, 0); 
            if(id > 0)
            {
                printf("wait success, exit code: %d\n", WEXITSTATUS(status));
            }
        }
    return 0;
}

3.子进程中执行自己写的py/sh程序

test.py
#! /usr/bin/python3.6
print("hello Python")
print("hello Python")
print("hello Python")

test.sh
#! /usr/bin/bash
echo "hello shell!"
echo "hello shell!"
echo "hello shell!"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM 16

int main(int argc, char*argv[], char *env[])
{
       pid_t id = fork();
        if(id == 0)
        {
            //子进程
            printf("子进程开始运行, pid: %d\n", getpid());
            sleep(3);
            在命令行下: python test.py === ./test.py (自动调用解释器)
            //execlp("./test.py", "test.py", NULL);
            //execlp("bash", "bash", "test.sh", NULL);
            //execlp("python", "python", "test.py", NULL);
            py/sh/java: 有解释器 在解释器(也是一个程序)内编译执行对应程序
            exit(1);
        }
        else 
        {
            //父进程
            printf("父进程开始运行, pid: %d\n", getpid());
            int status = 0;
            pid_t id = waitpid(-1, &status, 0); 
            if(id > 0)
            {
                printf("wait success, exit code: %d\n", WEXITSTATUS(status));
            }
        }
    return 0;
}

4. int execle(const char *path, const char *arg, …, char * const envp[]);

4.1自己写的C/C++程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("can not execute！\n");
        exit(1);
    }

    printf("获取环境变量: VIRTUALENV: %s\n", getenv("VIRTUALENV"));

    if(strcmp(argv[1], "-a") == 0)
    {
        printf("hello a!\n");
    }
    else if(strcmp(argv[1], "-b") == 0)
    {
        printf("hello b!\n");
    }
    else
    {
        printf("default!\n");
    }

    return 0;
}
4.2执行自己写的C/C++程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM 16

//const char *fileaddr = "/home/lhr/linux/procreplace/cmd";
const char *fileaddr = "./cmd";

int main(int argc, char*argv[], char *env[])
{
        /*char *const _env[NUM] = {
             (char*)"VIRTUALENV=547993",
              NULL
        };*/ok
        pid_t id = fork();
        if(id == 0)
        {
            //子进程
            printf("子进程开始运行, pid: %d\n", getpid());
            sleep(3);
            char *const _env[NUM] = {
                 (char*)"VIRTUALENV=547993",
                  NULL
            };//ok
        
            char *const _argv[NUM] = {
                (char*)"ls",
                (char*)"-a",
                (char*)"-l",
                (char*)"-i",
                NULL
            };
            execle(fileaddr, "cmd", "-a", NULL, _env);
            
            exit(1);
        }
        else 
        {
            //父进程
            printf("父进程开始运行, pid: %d\n", getpid());
            int status = 0;
            pid_t id = waitpid(-1, &status, 0);
            if(id > 0)
            {
                printf("wait success, exit code: %d\n", WEXITSTATUS(status));
            }
        }
    return 0;
}

_env写在父进程子进程都可以
写在父进程: _env作为环境变量传参给execle cmd.c从环境变量_env获取
写在子进程: _env作为环境变量传参给execle 即使进程替换 原来的代码和数据被完全替换 但是环境变量不会被替换 所以cmd.c仍能找到

还有另外两种方法 详见码云

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM 16

//const char *fileaddr = "/home/lhr/linux/procreplace/cmd";
const char *fileaddr = "./cmd";

int main(int argc, char*argv[], char *env[])
{
    extern char** environ;
    putenv("VIRTUALENV=666");
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        printf("子进程开始运行, pid: %d\n", getpid());
        sleep(3);

        char *const _argv[NUM] = {
            (char*)"ls",
            (char*)"-a",
            (char*)"-l",
            (char*)"-i",
            NULL
        };
       // putenv("VIRTUALENV=547993");//ok:env不会被替换 cmd.c仍能获取
       
       // execle(fileaddr, "cmd", "-a", NULL);//err:不传env, 指定子进程接收的是空环境变量
        execl(fileaddr, "cmd", "-a", NULL);//ok: 此函数不用传env参数 默认继承父进程
        
        //execle(fileaddr, "cmd", "-a", NULL, env);//只有在shell下export VIRTIUAL=1 子进程才能获取到env
        //execle(fileaddr, "cmd", "-a", NULL, environ);//子进程可以获取env

        //execl("/usr/bin/ls", "ls", "-a", "-l", NULL);
        //execv("/usr/bin/ls", _argv); 
        //execlp("ls", "ls", "-a", "-l", NULL);
        //execvp("ls", _argv);
        exit(1);
    }
    else 
    {
        //父进程
        printf("父进程开始运行, pid: %d\n", getpid());
        int status = 0;
        pid_t id = waitpid(-1, &status, 0);
        if(id > 0)
        {
            printf("wait success, exit code: %d\n", WEXITSTATUS(status));
        }
    }
    return 0;
}

特殊讲解
execle(fileaddr, "cmd", "-a", NULL, env);//只有在shell下export VIRTIUAL=1 子进程才能获取到env
execle(fileaddr, "cmd", "-a", NULL, environ);//子进程可以获取env

由此我们可以有一个大胆的猜想:shell进程创建子进程运行main main里put了一个env
然后main创建了一个子进程运行cmd 传env cmd获取不到env 传environ cmd可以获取env
即当我们put了env environ里就有 而env是shell进程的环境变量传给main的
此时main的env还没有TMPENV 如果提前在shell下export了一个TMPENV
此时再运行main main的env里就有了一个TMPENV 此时的put相当于对TMPENV进行了修改
如此再传env cmd也能获取到TMPENV

2.7 int execvpe(const char *file, char *const argv[], char *const envp[]);

同上类比

阿猿收手吧！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux 进程替换深剖
qq_61500888的博客
10-28 1269
带你一命通关 Linux 进程替换 十分钟手撕语法内涵
Linux进程控制详解及实例
09-15
Linux进程控制是操作系统的核心组成部分，它允许用户和系统创建、管理以及终止进程。在这个主题中，我们将深入探讨几个关键的Linux进程控制函数，包括fork()、exec家族、wait()和exit()，并提供实例来解释它们如何...
Linux进程控制（精讲）
热门推荐
2021dragon的博客
10-01 2万+
文章目录进程创建fork函数初始fork函数返回值写时拷贝fork常规用法fork调用失败的原因进程终止进程退出场景进程常见退出方法_exit函数exit函数return退出进程等待进程等待的必要性进程等待的方法wait方法waitpid方法获取子进程status具体代码实现进程程序替换替换原理替换函数函数解释命名理解做一个简易的shell 进程创建 fork函数初始 fork函数返回值 写时拷贝 fork常规用法 fork调用失败的原因 进程终止 进程退出场景 进程常见退出方法 _exit函数 exit函
【Linux】进程控制 —— 进程替换
Hello_World_213的博客
09-25 1249
[Linux]进程替换原理, exec系列系统调用, 用C程序执行其他语言程序, 模拟实现简单的shell(命令行解释器)
Linux进程控制【进程程序替换】
北 海的博客
03-19 4273
子进程在被创建后，共享的是父进程的代码，如果想实现自己的逻辑就需要再额外编写代码，为了能让子进程执行其他任务，可以把当前子进程的程序替换为目标程序，此时需要用到Linux进程程序替换相关知识
Linux进程控制
2303_76604972的博客
04-29 1804
网上的定义众说纷纭，但都大同小异，就我的理解而言，进程是运行起来的程序(指令)，同时还用于内存和地址空间等资源。一种后台服务进程，往往用于周期性地执行某种任务或等待处理某些发生的事件。例如，作业规划进程crond、打印进程lqd等（这里的结尾字母d就是Daemon的意思）Linux中，从某一终端启动的进程往往依赖于该终端，当终端关闭，进程也自动关闭，但守护进程不是，当系统关闭后才会结束。如果想让某个进程不因为用户、终端或者其他的变化而受到影响，那么就必须把这个进程变成一个守护进程。
12 Linux进程的控制
精致的灰的博客
10-13 1093
文章目录一、fork的补充1.1.写时拷贝1.2.fork调用失败的原因二、进程终止2.1.退出码2.2.正常退出returnexit_exit和exit的区别2.3.异常退出三、进程等待3.1.进程等待的方法waitwaitpidstatus3.2.创建多进程3.3.非阻塞等待子进程3.4.总结四、进程程序替换4.1.进程替换的函数4.2. execve五、实现一个简单的shell六、补充和总结内容 一、fork的补充 在之前已经了解了fork函数，这个函数是以父进程为“模板”创建子进程。父子进程的所有
Linux-进程控制
weixin_52199109的博客
10-24 1602
作为操作系统对于其中的进程控制，对于一个多进程少CPU的情况，操作系统要有一个组织调度进程的算法来合理分配资源。 进程调度队列 NICE与PRI 首先回顾一下NICE与PRI，这是表明进程的优先级的大小，越小，就代表进程优先级就越高。 NICE的范围是[-20,19],而PRI则默认是80.我们一般也只能通过控制NICE的值来间接影响PRI，从而改变进程的优先级。而NICE的区间也说明PRI的范围是[60,99]。也就是意味着，一个进程的优先级也就是在这个范围，且PRI越小，优先级越高。 运行队列-runq
【Linux 系统】进程控制 -- 详解
Elena's Blog
03-21 1754
如果子进程已经退出，调用 wait / waitpid 时，wait / waitpid 会立即返回，并且释放资源，获得子进程退出信息。如果在任意时刻调用 wait / waitpid，子进程存在且正常运行，则进程可能阻塞。如果不存在该子进程，则立即出错返回。思考：什么是进程替换？通过 exec* 函数，把磁盘中的其它程序（代码+数据）加载到内存中，替换当前进程的代码和数据，让页表重新构建映射关系，这期间不会创建新的进程。思考：为什么要进程替换？
关于Linux的进程管理控制器.zip
08-30
总的来说，这个压缩包提供的源码是一个实践性的Linux进程管理工具，它涵盖了进程创建、控制、信息获取以及定时任务等多个关键知识点，对于学习和理解Linux系统编程具有很高的价值。通过深入研究这些源码，开发者不仅...
LINUX进程控制编程
12-06
本主题“LINUX进程控制编程”旨在深入探讨这些概念，并教你如何在实际编程中应用它们。以下是对这个主题的详细阐述： 一、进程的基本概念 进程是程序在内存中的执行实例，每个进程都有独立的地址空间。在Linux中，...
进程实验_Linux系统进程实验_
09-30
提供的"word文档供学习参考"可能包含了实验步骤、示例代码和相关理论解释，对于深入理解和实践Linux进程编程非常有帮助。 在实际操作中，结合`man`手册页和实验指导，学习者可以更全面地掌握这些概念和操作，从而...
Linux环境下的进程
03-12
在Linux操作系统中，进程是程序执行的实例，是系统资源分配的基本单位。本文将深入探讨Linux环境下的进程，包括...了解这些知识点，能够帮助开发者更好地理解和控制Linux系统中的进程行为，提升系统的稳定性和性能。
建立共享linux第三方软件仓库
最新发布
Znj1421304181的博客
07-08 179
【代码】建立共享linux第三方软件仓库。
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 421
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
linux，docker，k8s常见命令
buaixuexideshuge的博客
07-07 873
命令
RedHat运维-LinuxSELinux基础4-端口绑定SELinux上下文
a15735748145a的博客
07-06 641
12. 将60001/tcp端口上的SELinux上下文由http_port_t调整为gopher_port_t的方法是______________________；13. 将60002/tcp端口上的SELinux上下文由gopher_port_t调整为ssh_port_t的方法是______________________；14. 将60003/tcp端口上的SELinux上下文由ssh_port_t调整为http_port_t的方法是_______________________；
Linux_实现简易日志系统
安权_code的博客
07-07 981
在Linux下实现一个日志系统，该日志系统主要用于打印和记录程序的格式化信息，还可以对信息做分析处理，比如把信息分为五种类型：正常运行信息、测试信息，警告信息，错误信息、致命信息，当然还可以显示信息产生的具体时间，并且能够对这些信息进行存档归类。
Linux x86_64平台指令替换函数 text_poke_smp/bp
小立仔
07-05 921
Linux x86_64平台指令替换函数 text_poke_smp/bp简介
linux 进程控制
09-07
进程控制是指对于操作系统中运行的进程进行管理和控制的一系列操作。在Linux系统中，进程控制包括创建、终止、暂停、恢复、等待等操作。 1. 创建进程：可以使用fork()函数创建子进程，fork()函数会返回两次，父进程返回子进程的PID，子进程返回0。另外，还可以使用exec()函数族中的一些函数来执行另一个程序，并将其替换为当前进程。 2. 终止进程：使用exit()函数来终止一个进程，也可以使用kill命令发送信号给进程来终止它。 3. 暂停和恢复进程：可以使用pause()函数使进程暂停执行，直到接收到一个信号为止。另外，可以使用kill命令发送SIGSTOP信号来暂停进程，使用SIGCONT信号来恢复暂停的进程。 4. 等待子进程：可以使用wait()或waitpid()函数来等待子进程的终止，并获得其终止状态。 此外，还有一些其他的进程控制相关的操作，如获取进程ID、获取父进程ID、修改进程优先级、设置信号处理函数等。这些操作可以通过系统调用或者使用相应的库函数来实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿猿收手吧！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值