Linux系统编程---文件系统

已于 2024-04-26 13:29:06 修改
阅读量1.4k 收藏 26
点赞数 40
分类专栏： Linux系统编程 文章标签： linux
于 2024-04-14 20:45:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51647149/article/details/137747354
版权

一、文件存储

一个文件主要由两部分组成，dentry(目录项)和inode

inode本质是结构体，存储文件的属性信息，如：权限、类型、大小、时间、用户、盘块位置…

也叫做文件属性管理结构，大多数的inode都存储在磁盘上。

少量常用、近期使用的inode会被缓存到内存中。

所谓的删除文件，就是删除inode，但是数据其实还是在硬盘上，以后会覆盖掉。

二、文件操作

1. stat函数：获取文件属性，（从inode结构体中获取）

int stat(const char *path, struct stat *buf);

参数：

        path： 文件路径

        buf：（传出参数） 存放文件属性，inode结构体指针。

返回值：

        成功： 0

        失败： -1 errno

获取文件大小： buf.st_size

获取文件类型： buf.st_mode

获取文件权限： buf.st_mode

符号穿透：stat会。lstat不会。

#include <stdio. h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread .h>
#include <sys/stat.h>

int main(int argc,char *argv[])
{
    struct stat sbuf;
    int ret = stat(argv[1], &sbuf);
    if(ret == -1)
    {
        perror( "stat error" );
        exit(1);
    }

    printf( "file size: %ld\n" , sbuf.st_size);

    return 0;
}

查看f.c文件大小执行：

./mystat f.c

2. lstat：查看文件类型，用法同stat

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>
#include<sys/stat.h>

int main(int argc,char *argv[])
{
        struct stat sbuf;
        int ret = lstat(argv[1],&sbuf);
        if (ret == -1)
        {
                perror("stat error");
                exit(1);
        }

        if (S_ISREG(sbuf.st_mode)){
                printf("It's a regular file\n");
        }else if(S_ISDIR(sbuf.st_mode)){
                printf("It's a dir\n");
        }else if (S_ISFIFO(sbuf.st_mode)){
                printf("It's a pipe\n");
        }else if(S_ISLNK(sbuf.st_mode)){
                printf("It's a sym link\n");
        }
        return 0;
}

stat会拿到符号链接指向那个文件或目录的属性---符号穿透

查看符号链接文件时不想让其穿透则使用lstat函数

首先对test.c创建一个软连接

ln -s test.c test.s/test.soft

查看改文件类型，执行以下代码：

./mystat test.s/test.soft

out:

It's a sym link

如果使用stat函数，则以上输出为：

It's a dir/It's a regular file

3.link和unlink隐式回收

int link(const char *oldpath, const char *newpath);

link 函数用于创建一个现有文件的新的硬链接。硬链接，不同于符号链接（软链接），是一个指向文件系统中某个 inode 的直接指针

参数
  • oldpath: 现有文件的路径。
  • newpath: 新链接的路径。
返回值
  • 成功: 返回0。
  • 失败: 返回-1。

int unlink(const char *pathname);

unlink 函数用于删除一个文件的硬链接。

  • unlink是删除一个文件的目录项dentry，使【硬链接数-1】
  • unlink函数的特征：如果这个链接是文件的最后一个链接（即文件的链接数变为0），文件将被删除，并释放占用的资源。如果文件被某个进程打开，它将保持打开状态直到最后一个文件描述符被关闭。

注意事项

  • 硬链接不能跨文件系统创建。
  • 不能为目录创建硬链接，以避免创建可能的循环结构，这可能会对文件系统的完整性造成破坏。
  • 符号链接（软链接）可以链接到目录，并可以跨文件系统链接。

link 和 unlink 函数的使用示例：

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

int main() {
    char *original = "/path/to/original/file.txt";
    char *linkname = "/path/to/link/file.txt";

    // 创建一个硬链接
    if (link(original, linkname) == -1) {
        perror("link");
        return 1;
    } else {
        printf("Hard link created successfully\n");
    }

    // 删除硬链接
    if (unlink(linkname) == -1) {
        perror("unlink");
        return 1;
    } else {
        printf("Hard link removed successfully\n");
    }

    return 0;
}

编程实现mv命令的改名操作：

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

int main(int argc,char *argv[])
{
        link(argv[1],argv[2]);
        unlink(argv[1]);
        return 0;
}

对tets.c改为tets1.c执行以下命令：

./mymv test.c test1.c

三、目录操作

1. getcwd函数

char *getcwd(char *buf, size_t size);

功能:获取当前进程的工作目录
参数:
        buf :缓冲区，存储当前的工作目录

        size :缓冲区大小
返回值:
        成功:buf中保存当前进程工作目录位置

        失败:NULL

2. chdir函数

int chdir(const char *path);

功能:修改当前进程(应用程序)的路径

参数:
        path:切换的路径

返回值:
        成功:0

        失败: -1

示例：

int main (void)
{
    int ret = -l;
    char buf[SIZE] ;

    //1、获取当前进程的工作目录memset(buf, 0, SIZE);
    if (NULL =getcwd(buf, SIZE))
    {
        perror("getcwd error");
        return 1;
    }

    printf( " buf: %s \n", buf);

    //2．改变当前进程的工作目录
    ret = chdir( "/home/deng");
    if (-1 ==ret)
    {
        perror ("chdir error");
        return 1;
    }

    //3．获取当前进程的工作目录memset(buf,0,SIZE);
    if (NULL == getcwd(buf,SIZE))
    {
        perror ("getcwd error");
        return 1;
    }

    printf("buf: %s\n" , buf);
}

3. opendir函数

DIR *opendir(const char *name) ;

功能:打开一个目录
参数:
        name:目录名

返回值:
        成功:返回指向该目录结构体指针

        失败:NULL

4. closedir函数

int closedir(DIR *dirp);

功能:关闭目录
参数:
        dirp: opendir返回的指针

返回值:
        成功:0

        失败: -1

示例：

//目录打开和关闭
int main(void)
{
    DIR *dir = NULL;

    //1．打开日录
    dir = opendir("test");
    if (NULL == dir)
    {
        perror ("opendir error");
        return l;
    }

    closedir(dir);
    return 0;
}

5. readdir函数

struct dirent *readdir(DIR *dirp);

功能:读取目录
参数:
        dirp: opendir的返回值

返回值:
        成功:目录结构体指针

        失败:NULL

相关结构体说明：

struct dirent{
        ino_t d_ino;        //此目录进入点的inode
        off_t d_off;        //目录文件开头至此目录进入点的位移
        signed short int d_reclen;        // d_name 的长度,不包含NULL字符
        unsigned char d_type;        // d_type所指的文件类型
        char d_name [256];        //文件名

}；

实现 ls -a 代码如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<dirent.h>

int main(int argc,char *argv[])
{
        DIR * dp;
        dp = opendir(argv[1]);
        if (dp == NULL){
                perror("opendir error");
                exit(1);
        }

        struct dirent *sdp;
        while((sdp = readdir(dp)) != NULL){
                printf("%s\t",sdp->d_name);
        }

        printf("\n");   

        closedir(dp);

        return 0;
}

在当前目录下使用命令，执行：./myls ./ 即展示当前目录下的文件及大小

 四、递归遍历目录

任务需求：使用opendir closedir readdir stat实现一个递归遍历目录的程序

输入一个指定目录，默认为当前目录。递归列出目录中的文件，同时显示文件大小。

思路分析

递归遍历目录：ls-R.c

1. 判断命令行参数，获取用户要查询的目录名。 int argc, char *argv[1]

                argc == 1 --> ./

2. 判断用户指定的是否是目录。 stat S_ISDIR(); --> 封装函数 isFile() { }

3. 读目录： read_dir() {

                   opendir（dir）

                   while （readdir（））{

                        普通文件，直接打印

                        目录：

                                拼接目录访问绝对路径。sprintf(path, "%s/%s", dir, d_name)

                                递归调用自己。--> opendir（path） readdir closedir

                     }

                     closedir（）

                     }

        read_dir() --> isFile() ---> read_dir()

代码示例：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<dirent.h>
#include<stdio.h>
#include<sys/stat.h>

#define PATH_LEN 256
//dir=/homeitgan/linux  fcn=isfile

void fetchdir(const char *dir,void (*fcn)(char *))
{
        char name[PATH_LEN];
        struct dirent *sdp;
        DIR *dp;

        if ((dp = opendir(dir)) == NULL){  //打开目录失败
                //perror("fetchdir can't open");
                fprintf(stderr,"fetchdir:can't open %s\n",dir);
                return;
        }
        while ((sdp = readdir(dp)) != NULL){
                if (strcmp(sdp->d_name,".") == 0  || strcmp(sdp->d_name,"..") == 0){       //防止出现无限递归
                continue;
                }

                if (strlen(dir)+strlen(sdp->d_name)+2>sizeof(name)){
                fprintf(stderr,"fetchdir:name %s %s too long\n",dir,sdp->d_name);
                }else{
                sprintf(name,"%s/%s",dir,sdp->d_name);
                (*fcn)(name);
                }
        }
        closedir(dp);
}

void isfile(char *name)
{
        struct stat sbuf;

        if(stat(name,&sbuf) == -1){
                fprintf(stderr,"isfile:can't access %s\n",name);
                exit(1);
        }
        if ((sbuf.st_mode & S_IFMT) == S_IFDIR){
                fetchdir(name,isfile);
        }
        printf("%8ld %s\n",sbuf.st_size,name);
}


int main(int argc,char *argv[])
{
        if(argc == 1)
                isfile(".");
        else
                while (--argc > 0) //可一次查询多个目录
                        isfile(*++argv);//循环调用该函数处理各个命令行传入的目录
        return 0;
}

执行 ./ls_R test.c 可查看test.c的文件大小

执行 ./ls_R 可查看当前目录下所有文件的大小

五、文件描述符复制

1. dup和dup2

用来做重定向，本质就是复制文件描述符

重定向：

cat myls.c > out        将myls.c的东西读出再写到out文件中

cat myls.c >> out      将myls.c的东西读出再追加到out文件中

dup()和dup2()用来做重定向，本质就是复制文件描述符，使新的文件描述符也标识旧的文件描述符所标识的文件；

这个过程类似于现实生活中的配钥匙，一把钥匙对应一把锁，然后我们又去配了一把新钥匙，此时两把钥匙都可以打开锁，而dup()和dup2()也一样，原来的文件描述符和新复制出来的文件描述符都指向同一个文件，我们操作这两个文件描述符的任何一个 都能操作它所对应的文件

dup函数

int dup(int oldfd);

功能:
        通过oldfd复制出一个新的文件描述符，新的文件描述符是调用进程文件描述符表中最小可用的文件描述符，最终oldfd和新的文件描述符都指向同一个文件。
参数:
        oldfd :需要复制的文件描述符oldfd

返回值:
        成功:新文件描述符

        失败:-1

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>

int main(int argc,char *argv[])
{
        int fd = open("./out",O_RDONLY);//012 ---3
        
        int newfd = dup(fd);//4

        printf("newfd = %d\n",newfd);

        return 0;
}

make之后执行输出为：newfd = 4

dup2函数：

int dup2(int oldfd，int newfd);

功能:
        通过oldfd 复制出一个新的文件描述符newfd，如果成功，newfd和函数返回值是同一个返回值，最终oldfd和新的文件描述符newfd都指向同一个文件。
参数:
        oldfd :需要复制的文件描述符
        newfd :新的文件描述符，这个描述符可以人为指定一个合法数字(0 - 1023)，如果指定的数字已经被占用（和某个文件有关联)，此函数会自动关闭close()断开这个数字和某个文件的关联，再来使用这个合法数字。
返回值:
        成功:返回newfd

        失败:返回-1

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
#include<fcntl.h>

int main(int argc,char *argv[])
{
        int fd1 = open(argv[1],O_RDWR);//012---3

        int fd2 = open(argv[2],O_RDWR);//0123---4
        
        int fdret = dup2(fd1,fd2);//返回新文件描述符fd2

        printf("fdret = %d\n",fdret);
        
        int ret = write(fd2,"1234567",7);//写入fd1指向的文件
        
        printf("ret = %d\n",ret);
        
        dup2(fd1,STDOUT_FILENO);//将屏幕输入重定向给fd1所指向的文件

        printf("-------------------886\n");

        return 0;
}

首先新建2个空白文件out和out1

make之后执行以下命令：

./dup2 out out1

首先1234567会写入out文件中，其次再将-------------------886写入out文件

int fdret = dup2(fd1,fd2);        其中fd1 = 3，fd2 = 4

把3拷贝给4，即把4指向3(out文件)

dup2(fd1,STDOUT_FILENO);        STDOUT_FILENO = 1

把3拷贝给1，即把1指向3(out文件)

此时指向out的文件描述符有三个

2. fcntl函数

  • fcntl用来改变一个【已经打开】的文件的 访问控制属性
  • 重点掌握两个参数的使用， F_GETFL，F_SETFL

int fcntl(int fd, int cmd, ...)

参数：

        fd 文件描述符

        cmd：指定要执行的操作类型。这个参数可以取多个值，常见的有：

                获取文件状态： F_GETFL

                设置文件状态： F_SETFL       

                获取文件描述符：F_GETFD

                设置文件描述符：F_SETFD

                复制文件描述符：F_DUPFD

                获取文件锁定状态：F_GETLK

                设置文件锁定状态(非阻塞)：F_SETLK

                设置文件锁定状态(阻塞)：F_SETLKW

        int flgs = fcntl(fd, F_GETFL);

        flgs |= O_NONBLOCK

        fcntl(fd, F_SETFL, flgs);

返回值： 

        成功：根据 cmd 操作的不同，返回值也不同（例如，F_GETFL 返回文件状态标志）。

        失败：返回 -1 并设置 errno 以指示错误原因。

使用 fcntl() 来设置文件为非阻塞模式:

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

int main() {
    int fd, flags;

    // 打开文件
    fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Open file");
        exit(EXIT_FAILURE);
    }

    // 获取当前的文件状态标志
    flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) {
        perror("fcntl - F_GETFL");
        exit(EXIT_FAILURE);
    }

    // 添加非阻塞标志
    flags |= O_NONBLOCK;
    if (fcntl(fd, F_SETFL, flags) == -1) {
        perror("fcntl - F_SETFL");
        exit(EXIT_FAILURE);
    }

    // 继续做其他工作，比如读取文件

    close(fd);
    return 0;
}

终端文件默认是阻塞读的，这里用fcntl将其更改为非阻塞读：

#include <unistd.h>  
#include <fcntl.h>  
#include <errno.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
  
#define MSG_TRY "try again\n"  
  
int main(void)  
{  
    char buf[10];  
    int flags, n;  
  
    flags = fcntl(STDIN_FILENO, F_GETFL); //获取stdin属性信息  
    if(flags == -1){  
        perror("fcntl error");  
        exit(1);  
    }  
    flags |= O_NONBLOCK;  
    int ret = fcntl(STDIN_FILENO, F_SETFL, flags);  
    if(ret == -1){  
        perror("fcntl error");  
        exit(1);  
    }  
  
tryagain:  
    n = read(STDIN_FILENO, buf, 10);  
    if(n < 0){  
        if(errno != EAGAIN){          
            perror("read /dev/tty");  
            exit(1);  
        }  
        sleep(3);  
        write(STDOUT_FILENO, MSG_TRY, strlen(MSG_TRY));  
        goto tryagain;  
    }  
    write(STDOUT_FILENO, buf, n);  
  
    return 0;  
}

 fcntl实现dup描述符：

int fcntl(int fd, int cmd, ....);

cmd: F_DUPFD

参3:         

        被占用的，返回最小可用的。

        未被占用的， 返回=该值的文件描述符。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
#include<pthread.h>

int main(int argc, char *argv[])
{
        int fd1 = open(argv[1],O_RDWR);

        printf("fd1 = %d\n",fd1);

        int newfd = fcntl(fd1,F_DUPFD,0);//0被占用，fcntl使用文件描述符表中可用的最小文件描述符返回
        printf("newfd = %d\n",newfd);

        int newfd2 = fcntl(fd1,F_DUPFD,7);//7未被占用，返回>=7的文件描述符
        printf("newfd2 = %d\n",newfd2);

        int ret = write(newfd2,"YYYYYYYYYYYYY",7);//只能写入7个
        printf("ret = %d\n",ret);

        return 0;
}

 make之后执行：

./fcntl_dup out

out：

fd1 = 3
newfd = 4
newfd2 = 7
ret = 7

菜就多练wwww
关注
  • 40
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内核模块编程-proc文件系统
zyfforlinux
11-11 3864
什么是procproc文件系统是一个伪文件系统，它只存在内存当中，而不占用外存空间。它以文件系统的方式为访问系统内核数据的操作提供接口。用户和应用程序可以通过proc得到系统的信息，并可以改变内核的某些参数。由于系统的信息，如进程，是动态改变的，所以用户或应用程序读取proc文件时，proc文件系统是动态从系统内核读出所需信息并提交的。 来自于百度百科 使用proc在内核态和用户态传递数据创建p
Linux系统编程--文件系统1
08-08
Linux系统编程--文件系统1 Linux 文件系统是指计算机操作系统中负责文件存储、检索和管理的组件。在 Linux 中，文件系统是一组规则，规定对文件的存储及读取的一般方法。文件系统在磁盘格式化过程中指定。常见的...
Linux 系统编程 -进程概念篇
qq_45313714的博客
06-14 1万+
Linux系统编程-进程篇冯诺依曼体系结构冯诺依曼的两个重要思想当代计算机的三级缓存操作系统操作系统的概念操作系统的组成操作系统作用Linux下的操作系统体系进程进程概念进程特性进程的组成进程与程序区别进程控制块Linux下的底层下的组织明确Linux操作系统底层Linux底层管理进程的结构体(描述)从操作系统内核的结构看进程(组织)查看进程命令 冯诺依曼体系结构 这里的存储器是内存，一般情况下内存不直接与外存打交道，而是通过缓存先将输入/输出 输出到寄存器中，再由寄存器与外存做交互。 当代典型的输入设备
黑马程序员-Linux系统编程-01
m0_55093622的博客
02-20 1976
linux应用编程
嵌入式学习之linux系统编程----1 了解linux编程并且在ubuntu以及ARM上运行测试程序
qq_42822743的博客
03-12 2714
1、何为linux系统编程？ linux系统编程也称为linux下的高级编程，它介于应用层与驱动层之间。 一般来说分为三个层面，分别是：应用层（写一个qt程序或者c程序就属于是应用层面）、驱动层（比如写一个蜂鸣器、led等）以及硬件层（与开发板相关的）。 2、linux系统编程基本程序框架 先从最简单的程序开始说起（helloworld.c） #include <stdio.h> #include <stdlib.h> int main(void) { printf
嵌入式学习之Linux系统编程---9 目录IO之readdir函数
qq_42822743的博客
03-29 4431
1、readdir函数的函数原型 #include <dirent.h> struct dirent *readdir(DIR *dirp); 对于readdir函数来说，它只有目录流指针这一个参数，这个目录流指针就是使用opendir这个函数大尅的返回值。 该函数在man手册的第三页，该函数如果执行成功，则返回的是一个结构体指针，失败则返回的是NULL，读到末尾也是返回NULL。 2、readdir函数的应用示例 3、思考 如果读取的目录下面会有很多个文件（不止一个文件），那么读取出来的结果
Linux文件--文件命名规则
醉卧考场君莫笑
09-07 4207
大部分和其他语言差不多。
Linux系统调用 - close
yubo112002的专栏
10-23 1万+
Close
【linux应用编程】-获取系统时间
钟浩森的博客
04-02 5178
第一点 关于时间的概念 GMT时间 格林尼治时间，可自行百度！ UTC时间 现在常用的时间概念！自行百度 计算机中的时间 点时间（RTC：实时时间） 段时间（定时器实现） 第二点 linux系统中的时间 jiffies的引入 他是内核中的一个全局变量，用来记录以内核节拍时间（也就是调度时间、取决于操作系统的配置、一般为1ms/10ms）为时间单位的一个时间长度。 linux系统如何记录时间 liunx内核启动时，jiffies就有一个基准值（是通过调用RTC所获得的当前时间点值换
Linux编程--文件描述符fd
热门推荐
SevenFighting的专栏
10-22 1万+
    linux中， 每一个进程在内核中，都对应有一个“打开文件”数组，存放指向文件对象的指针，而 fd 是这个数组的下标。     我们对文件进行操作时，系统调用，将fd传入内核，内核通过fd找到文件，对文件进行操作。     既然是数组下标，fd的类型为int， &lt; 0 为非法值， &gt;=0 为合法值。在linux中，一个进程默认可以打开的文件数为1024个，fd的范围为0~1...
Linux系统文件权限管理
CSDN
01-04 1万+
PAM 可以说是一套应用程序编程接口(Application Programming Interface,API)他提供了一连串的验证机制,只要使用者将验证阶段的需求告知 PAM 后,PAM 就能够回报使用者验证的结果(成功或失败),由于 PAM 仅是一套验证的机制,又可以提供给其他程序所呼叫引用,因此不论你使用什么程序,都可以使用 PAM 来进行验证,如此一来,就能够让账号口令或者是其他方式的验证具有一致的结果,也让程序设计师方便处理验证的问题.
linux系统编程_linux系统编程-中文_
10-04
首先，Linux系统编程的基础包括了解Linux内核，它是操作系统的核心部分，负责管理硬件资源，提供进程调度、内存管理、文件系统等功能。学习Linux系统编程，你需要理解进程生命周期，包括创建、执行、通信、同步和...
Linux系统编程--文件IO1
08-08
《TCP/IP 详解》(3卷)，《UNIX网络编程》（2卷）参考书2：《Linux系统编程》RobertLoVe [美] 参考书3：《Linux/UNIX系统编
01--Linux系统编程-文件IO.pdf
10-08
linux 开发者，学习c ,c++
Linux操作系统编程教学pdf
01-10
这个压缩包包含了一系列关于Linux操作系统编程的PDF教程，涵盖了多个关键主题，对于想要深入理解Linux系统编程的初学者和开发者来说，是非常宝贵的资源。 首先，我们来看"1.6 常用Linux命令- 用户及权限管理类命令....
Linux：基础命令学习
qq_55038440的博客
07-20 864
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
Linux小程序——进度条
最新发布
m0_66182473的博客
07-23 526
进度条
linux学习笔记整理: 关于linux:Shell脚本 2024/7/20；
gzx233的博客
07-20 881
Shell脚本的使用
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 1006
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
00-linux系统编程常识-王保明
01-21
本书系统地介绍了Linux系统编程的概念、原理和方法，涵盖了进程管理、文件操作、内存管理、多线程编程、网络编程等多个方面，使读者能够全面掌握Linux系统编程的相关知识。 王保明在书中以通俗易懂的语言对Linux...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值