LinuxC编程——实现自己的ls -R -a -l

最新推荐文章于 2023-02-28 20:30:13 发布
最新推荐文章于 2023-02-28 20:30:13 发布
阅读量4k 收藏 18
点赞数 1
分类专栏： LinuxC编程 LinuxC文件操作 文章标签： 参数 编程 代码 ls
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuxinquan61/article/details/47035395
版权

要实现自己的ls命令首先要有自己的框架结构，完整的框架结构不至于让你在编写代码的过程中突然没了思路。我的思路如下：

  1. 首先就是解析参数，对于参数的解析，可以采用或运算来定义，比如将没有参数定义为0，将-a定义为1，将-l定义为2，将-R定义为4等，这样的优点实质就是采取了二进制位的或运算的优势，对与每一位刚好代表不同的参数，这样就可以将所有的参数保存在一个int型的数中，当后面要查看是否有某个参数时，只需要判断一下这一位是否是1，即就是在使用一次与运算来得到结果。

  2. 对于目录的解析与参数是类似的，但是首先就是要将目录的参数与ls的参数（-a, -l, -R）能够区分开来，那么一个明显的标志就是ls命令本身的参数在之前是带有字符 ‘-’ 的，因而我们可以很方便的将两种参数区分开来，从而获得路径的参数。

  3. 对于显示，应当是由目录的解析开始，对于目录，我们可以使用opendir()函数来进行读取从而得到这一个文件夹中文件的名称，并将其使用 strcat()函数连接在path之后，组合成为带有文件名的pathname，其实到这里就等于将一个文件的完整路径包括文件名在内的完整信息的到了，然后反复利用opendir函数得到本目录下所有的完整文件路径将其存入一个二维数组当中。

  4. 接下来就是显示的工作，对于 ‘-a’ 参数和没有参数区别在于是否显示隐藏文件。对于这样的区别只需要用一个if条件进行判断文件名的开头是否是 ’ . ’ 即可。对于-l，则需要将文件的所有信息进行输出，即就是在-l输出函数内部要将文件的读取权限，链接数，所有者，所属组，文件名，时间信息统统显示出来，在往 ‘-l’ 信息输出函数的参数传递中就要将包含文件明的完整路径信息以及文件属性信息传入到-l输出函数中，然后在本函数中将属性的所有信息进行输出即可。

  5. 最后就是-R参数的输出，对于-R参数的最后的输出实质依旧是利用以上的函数，只是增加了递归调用，以及路径名的改变。在这一递归函数中，起初也是传入一个路径名，然后利用与之前相同的-a将此目录进行显示输出，不过，才此需要注意的是，到这里只是将当前路径名下的文件以及目录进行了输出，然后就是将当前path加上本文件夹下的文件夹的名称组成 pathname当做path重新调用-R输出函数，使之递归输出。需要注意的是在输出完成之后返回上一层目录，准备将下一个文件夹接到path后面之前要先将之前path后面接的name删除掉，这样每次递归调用返回到上一层之后可以保证父目录没有被改变。

注意：
  1. 在执行输出时有时侯打开文件夹需要权限，所以可以再sudo下执行
  2. 在执行-R递归显示时由于堆栈区大小限制，可能导致堆栈区溢出，测试时可对低级目录进行测试

具体代码如下：


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<sys/stat.h>
#include<unistd.h>
#include<sys/types.h>
#include<linux/limits.h>
#include<dirent.h>
#include<grp.h>
#include<pwd.h>
#include<errno.h>


#define PARAM_NONE 0    //无参数
#define PARAM_A 1   //-a :显示所有文件
#define PARAM_L 2 //-l ：一行显示一个文件的详细信息
#define PARAM_r 4 //-r : 逆序排列输出
#define MAXROWLEN 80 //一行最多显示的字符数
void ls_R(int, char **);
int recursion(int, char *);
int g_leave_len = MAXROWLEN;    //一行剩余长度，用于输出对齐
int g_maxlen;   //存放某目录下最长的文件名的长度

//错误打印函数
void my_err(const char *err_string, int line)
{
    fprintf(stderr, "line:%d ", line);
    perror(err_string);
    exit(1);
}

//获取文件属性并打印
void display_attribute(struct stat buf, char * name)
{
    char buf_time[32];
    struct passwd *psd;     //从该结构体获取文件所有者的用户名
    struct group *grp;      //从该结构体获取文件所有者所属组的组名

    //获取并打印文件类型
    if (S_ISLNK(buf.st_mode))
    {
        printf("l");
    }
    else if (S_ISREG(buf.st_mode))
    {
        printf("-");
    }
    else if (S_ISDIR(buf.st_mode))
    {
        printf("d");
    }
    else if(S_ISCHR(buf.st_mode))
    {
        printf("c");
    }
    else if (S_ISBLK(buf.st_mode))
    {
        printf("b");
    }
    else if (S_ISFIFO(buf.st_mode))
    {
        printf("f");
    }
    else if(S_ISSOCK(buf.st_mode))
    {
        printf("s");
    }

    //获取并打印文件所有者的权限
    if(buf.st_mode & S_IRUSR)
    {
        printf("r");
    }
    else
    {
        printf("-");
    }
    if(buf.st_mode & S_IWUSR)
    {
        printf("w");
    }
    else
    {
        printf("-");
    }
    if(buf.st_mode & S_IXUSR)
    {
        printf("x");
    }
    else
    {
        printf("-");
    }

    //获取并打印与文件所有者同组的用户对该文件的操作权限
    if(buf.st_mode & S_IRGRP)
    {
        printf("r");
    }
    else
    {
        printf("-");
    }
    if(buf.st_mode & S_IWGRP)
    {
        printf("w");
    }
    else
    {
        printf("-");
    }
    if(buf.st_mode & S_IXGRP)
    {
        printf("x");
    }
    else
    {
        printf("-");
    }

    //获取并打印其他用户对该文件的操作权限
    if (buf.st_mode & S_IROTH)
    {
        printf("r");
    }
    else
    {
        printf("-");
    }
    if (buf.st_mode & S_IWOTH)
    {
        printf("w");
    }
    else
    {
        printf("-");
    }
    if (buf.st_mode & S_IXOTH)
    {
        printf("x");
    }
    else
    {
        printf("-");
    }

    printf("    ");

    //根据uid与gid获取文件所有者的用户名与组名
    psd = getpwuid(buf.st_uid);
    grp = getgrgid(buf.st_gid);
    printf("%4d ", (int)buf.st_nlink);   //打印文件的链接数
    printf("%-12s", psd->pw_name);
    printf("%-12s", grp->gr_name);

    printf("%6d", (int)buf.st_size);     //打印文件大小
    strcpy(buf_time, ctime(&buf.st_mtime));
    buf_time[strlen(buf_time) - 1] = '\0';  //取掉换行符
    printf("  %s", buf_time);   //打印文件的时间信息
}

//在没有使用-l选项时，打印一个文件名，打印时保证上下对齐
void display_single(char *name)
{
    int i,len;

    //如果本行不足以打印一个文件名则换行
    if(g_leave_len < g_maxlen)
    {
        printf("\n");
        g_leave_len = MAXROWLEN;
    }

    len = strlen(name);
    len = g_maxlen - len;
    printf("%-s", name);

    for (i = 0; i < len; i++)
    {
        printf(" ");
    }
    printf("  ");
    g_leave_len -= (g_maxlen + 2);  //2指示两空格
}

//根据命令行参数和完整路径名显示目标文件
//参数flag：命令行参数
//参数pathname：包含了文件名的路径名

void display(int flag, char *pathname)
{
    int i,j;
    struct stat buf;
    char name[NAME_MAX + 1];

    //从路径中解析出文件名
    for(i = 0, j = 0; i < strlen(pathname); i++)
    {
        if(pathname[i] == '/')
        {
            j = 0;
            continue;
        }
        name[j++] = pathname[i];
    }
    name[j] = '\0';

    //用lstat而不是stat以方便解析链接文件
    if(lstat(pathname, &buf) == -1)
    {
        printf("权限不足！！\n");
        return ; 
        my_err("stat", __LINE__);
    }

    switch(flag)
    {
        case PARAM_NONE:    //没有-l和-a选项
        if(name[0] != '.')
        {
            display_single(name);
        }
        break;

        case PARAM_r:    //-r
        if(name[0] != '.')
        {
            display_single(name);
        }
        break;

        case PARAM_A:   //-a:显示包括隐藏文件在内的所有文件
        display_single(name);
        break;

        case PARAM_L:   //-l:每个文件单独占一行
        if(name[0] != '.')
        {
            display_attribute(buf, name);
            printf(" %-s\n", name);
        }
        break;

        case PARAM_A + PARAM_L:     //同时有-a和-l选项的情况
        display_attribute(buf, name);
        printf(" %-s\n", name);
        break;

        case PARAM_r + PARAM_A:    //-ar
        display_single(name);
        break;

        case PARAM_L + PARAM_r:     //-rl
        if(name[0] != '.')
        {
            display_attribute(buf, name);
            printf(" %-s\n", name);
        }
        break;

        defualt:
        break;
    }
}

void display_dir(int flag_param, char *path)
{
    DIR *dir;
    struct dirent *ptr;
    int count = 0;
    char filename[600][PATH_MAX+1],temp[PATH_MAX + 1];

    //获取该目录下文件总数和最长文件名
    dir = opendir(path);
    if (dir == NULL)
    {
        my_err("opendir", __LINE__);
    }
    while((ptr =readdir(dir)) != NULL)
    {
        if(g_maxlen < strlen(ptr->d_name))
        {
            g_maxlen = strlen(ptr->d_name);
        }
        count++;
    }
    closedir(dir);

    if(count > 600)
    {
        //printf("%d", count);
        my_err("too many file under this dir", __LINE__);
    }

    int i, j, len = strlen(path);
    dir = opendir(path);    //获取该目录下所有的文件名
    for(i = 0; i < count; i++)
    {
        ptr = readdir(dir);
        if(ptr == NULL)
        {
            my_err("readdir", __LINE__);
        }
        strncpy(filename[i], path, len);
        filename[i][len] = '\0';
        strcat(filename[i], ptr->d_name);
        filename[i][len + strlen(ptr->d_name)] = '\0';
    }
    closedir(dir);

    //使用冒泡法对文件名进行排序，排序后文件名按字母顺序存储与filename
    if(flag_param & PARAM_r)
    {
        for(i = 0; i < count - 1; i++)
        {
            for(j = 0; j < count - 1 - i; j++)
            {
                if(strcmp(filename[j], filename[j+1]) < 0)
                {
                    strcpy(temp, filename[j + 1]);
                    temp[strlen(filename[j+1])] = '\0';
                    strcpy(filename[j+1], filename[j]);
                    filename[j+1][strlen(filename[j])] = '\0';
                    strcpy(filename[j], temp);
                    filename[j][strlen(temp)] = '\0';
                }
            }
        }
    }
    else 
    {
        for(i = 0; i < count - 1; i++)
        {
            for(j = 0; j < count - 1 - i; j++)
            {
                if(strcmp(filename[j], filename[j+1]) > 0)
                {
                    strcpy(temp, filename[j + 1]);
                    temp[strlen(filename[j+1])] = '\0';
                    strcpy(filename[j+1], filename[j]);
                    filename[j+1][strlen(filename[j])] = '\0';
                    strcpy(filename[j], temp);
                    filename[j][strlen(temp)] = '\0';
                }
            }
        }
    }

    for(i = 0; i < count; i++)
    {
        display(flag_param, filename[i]);
    }


    //如果命令行没有-l选项，打印一个换行符          
    if((flag_param & PARAM_L) == 0)
    {
        printf("\n");
    }
}

int main(int argc, char **argv)
{
    int i, j, k, num;
    //char path[PARAM_NONE + 1];
    char param[32];     //保存命令行参数，目标文件和目录名不在此例
    int flag_param = PARAM_NONE;    //参数种类，即是否有-l和-a选项
    struct stat buf;

    char *path = (char*)malloc(PATH_MAX+1);
    //命令行参数的解析，分析-l,-a,-al,-la选项
    j = 0;
    num = 0;
    for(i = 1; i < argc; i++)
    {
        if(argv[i][0] == '-')
        {
            for(k = 1; k < strlen(argv[i]); k++, j++)
            {
                param[j] = argv[i][k];  //获取'-'后面的参数保存到数组param中
            }
            num++;      //保存'-'的个数
        }
    }

    //只支持a和l和r，如果含有其它选项就报错
    for(i = 0; i < j; i++)
    {
        if(param[i] == 'a')
        {
            flag_param |= PARAM_A;
            continue;
        }
        else if(param[i] == 'l')
        {
            flag_param |= PARAM_L;
            continue;
        }
        else if(param[i] == 'r')
        {
            flag_param |= PARAM_r;
            continue;
        }
        else if(param[i] == 'R')
        {
            free(path);
            ls_R(argc, argv);
        }
        else
        {
            printf("my_ls: invalid opention -%c\n", param[i]);
            exit(1);
        }
    }
    param[j] = '\0';

    //如果没有输入文件名或目录，就显示当前目录
    if((num + 1) == argc)
    {
        strcpy(path, "./");
        path[2] = '\0';
        display_dir(flag_param, path);
        return 0;
    }

    i = 1;
    do
    {
        //如果不是目标文件名或目录，解析下一个命令行参数
        if(argv[i][0] == '-')
        {
            i++;
            continue;
        }
        else 
        {
            //printf("%d\n", i);
            //strcpy(path, argv[i]);
            strncpy(path, argv[i],strlen(argv[i])+1);
            //如果目标文件或目录不存在，报错并退出程序
            //printf("%d\n", i);
            //puts(path);
            if(stat(path, &buf) == -1)
            {
                my_err("stat", __LINE__);
            }
            if(S_ISDIR(buf.st_mode))    //argv[i]是一个目录
            {
                if(path[strlen(argv[i])-1] != '/')  //如果目录的最后一个字符不是'/',就加上'/'
                {
                    path[strlen(argv[i])] = '/';
                    path[strlen(argv[i]) + 1] = '\0';
                }
                else
                {
                    path[strlen(argv[i])] = '\0';
                }
                display_dir(flag_param, path);
                i++;
            }
            else    //argv[i]是一个文件
            {
                display(flag_param, path);
                i++;
            }
        }
    }while(i < argc);
    return 0;
}

void ls_R(int argc, char **argv)
{
    int flag_param = 0;
    struct stat buf;
    int i;
    char path[500];
    for(i = 1; i < argc; i++)
    {
        if(argv[i][0] != '-') 
        {
            strcpy(path, argv[i]);
        }
    }
    printf("\n%s:\n", path);
    recursion(flag_param, path);
    exit(0);
}

int recursion(int flag, char *path)
{
    DIR *dir;
    struct dirent *ptr;     
    char pathname[10000];     //带有文件名称的路径
    int flag_param = 0;
    struct stat buf;
    int len, i;
    display_dir(flag_param, path);
    //pathname = (char *)malloc(PATH_MAX);
    strcpy(pathname, path);
    dir = opendir(path);
    while(1)
    {
        ptr = readdir(dir);
        if(ptr == NULL)
        {
            closedir(dir);
            return 1;
        }
        if(!(strcmp(ptr->d_name,".") && (strcmp(ptr->d_name, "..") && ptr->d_name[0] != '.')))
        {
            continue;
        }
        strcat(pathname, ptr->d_name);
        lstat(pathname, &buf);
        if(S_ISDIR(buf.st_mode))
        {
            len = strlen(pathname);
            pathname[len] = '/';
            pathname[len + 1] = '\0';
            printf("\n%s:\n", pathname);
            g_maxlen = 0;
            g_leave_len = MAXROWLEN;
            recursion(flag, pathname);
        }
        for(i = strlen(path); i < len ; i++)
        {
            pathname[i] = '\0';
        }
    }
}
zhuxinquan61
关注
  • 1
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统编程——线程私有数据-附件资源
03-02
Linux系统编程——线程私有数据-附件资源
Linux中ls -a,-l,-r,-R命令的实现
热门推荐
Sanjiye的博客
07-23 3万+
ls简介ls是我们使用Linux最常用的命令，可以用来打印当前目录或者制定目录的清单，显示出文件的一些信息等。 ls -a可以将目录下的全部文件（包括隐藏文件）显示出来 ls -l 列出长数据串，包括文件的属性和权限等数据 ls -r将排序结果反向输出，例如：原本文件名由小到大，反向则由大到小 ls -R连同子目录一同显示出来，也就所说该目录下所有文件都会显示出来（显示隐藏文件要加-a参数）
Linux基本操作1
qq_66581313的博客
09-20 1191
对于我们日常的使用来说，操作系统是必须的，没有操作系统，就没有图像化界面，没有图形化界面，我们只能输入命令行。我们在文本文件中输入字符，其中的字符就是我们的文件内容数据，当我们输入文件内容时，我们的文件大小发生了改变。例如这里的：文件类型，位置，大小，创建时间等等，这些数据都是文件的属性数据，属性数据也是占据硬盘空间的。如图所示，我们的a是目录，我们的A也同样是目录，所以目录中是可以有目录的。其中，路上节点只能是目录，叶子节点可能是目录，也可能是普通文件。
Linux常用指令介绍（一）
SAKURAjinx的博客
10-06 997
为什么它如此重要，因为find命令去系统里帮你找东西，是全盘仔细地搜索，甚至没有加载到内存的在磁盘中的文件都能帮你找出来，当然需要花上一定的时间，成本比较高，效率比较低，但是查出来的东西都比较真实。1、可以先创建一个新文件，用head 取出前5010行，重定项 > 到新文件中，再用tail -10就可以得到中间10行的内容了，这样做需要创建新文件不太合适。一边是入口，一边是出口。-a或–all 详细输出所有信息，依次为内核名称，主机名，内核版本号，内核版本，硬件名，处理器类型，硬件平台类型，操作系统名称。
ls 命令中的-r选项的含义
weixin_43161620的博客
02-21 3757
-r: 以目录的每个首字符所对应的ASCII值进行大到小排序  
Linux上简单实现的 ls命令
weixin_47847781的博客
11-04 532
文件权限：首位分为“-：文件”，“d：目录”，“l：软链接”，剩下其余9位每三位为一个整体代表所属用户权限、所属组权限、其他用户权限（-：无权限，r：读权限，w：写权限，x：执行权限）ls 命令是Linux下最常用的指令之一，为英文单词 list 的缩写，功能是列出指定目录下的内容及其相关属性信息。如下是ls功能的实现代码（自己代码尚未未完成，本代码为转载原文连接板在末尾。以下命令是在Linux系统上试验操作的。
用c语言编程实现ls功能,课上补做：用C语言编程实现ls命令
weixin_35657099的博客
05-18 1381
课上补做：用C语言编程实现ls命令一、有关lsls :用来打印当前目录或者制定目录的清单，显示出文件的一些信息等。ls -l:列出长数据串，包括文件的属性和权限等数据ls -R:连同子目录一同显示出来，也就所说该目录下所有文件都会显示出来ls -a:可以将目录下的全部文件(包括隐藏文件)显示出来ls -r:将排序结果反向输出二、参考伪代码实现ls的功能，提交代码的编译，运行结果截图。打开目录文件针...
c实现ls命令
m0_73852788的博客
02-28 767
ls可以说是一个linuxer最常用的一个基础命令了，今天学习一下ls背后的逻辑，加深对ls的理解，并试着自己用c语言实现。
linux输入ls命令报错,linux下实现ls命令
weixin_35698952的博客
04-29 808
Linux下实现ls命令(仅适用于ls-a pathname ; ls -l pathname; ls pathname )ls命令就是list的缩写,缺省下ls用来打印出当前目录的清单，如果ls指定其他目录，那么就会显示指定目录里的文件及文件夹清单。通过ls命令不仅可以查看linux文件夹包含的文件，而且可以查看文件权限(包括目录、文件夹、文件权限)，查看目录信息等等，ls命令在日常的linu...
自定义函数实现linux ls -a -l 命令_ls函数linux_自定义函数实现linux命令_
10-01
自定义函数实现linux ls -a -l 命令
ls -R 递归显示
12-17
这是自己写的ls -R函数，实现了分栏、隐藏文件隐藏、上色等功能，没有排序。用的时候根据输入不同有两种功能 ls 和ls -R 、用的时候只要再加一个主函数就可以了。
linux编程ls指令实现
11-27
实现递归的ls功能和基本的ls功能。 -r 递归，-l详细信息，-a显示包括隐藏
my_wc.rar_c实现wc命令_linux wc_linux wc -l
09-22
用C语言实现linux的wc命令，统计文件的行数，字符数，词组数，格式为my_wc filename
ls-l.c以c语言的方式实现ls-l
08-28
以c语言的方式实现ls-l
linux学习：ls命令说明
ycr19921121的博客
07-13 897
ls命令说明： ls命令用来显示目标列表，在Linux中是使用率较高的命令。ls命令的输出信息可以进行彩色加亮显示，以分区不同类型的文件。 语法 ls（选项）（参数） 选项 -a：显示所有档案及目录（ls内定将档案名或目录名称为“.”的视为影藏，不会列出）； -A：显示除影藏文件“.”和“..”以外的所有文件列表； -C：多列显示输出结果。这是默认选项； -l：与“-C”选项功能相
在Linux下：用 C 语言实现 ls 命令
代码改变世界
12-29 1万+
这次主要的目的是用 C语言 实现 Linux 系统中的 ls 命令。在编写命令之前，需要介绍一下几个结构体：第一个 DIR：struct __dirstream { void *__fd; char *__data; int __entry_data; char *__ptr; int __entry_ptr; size_t __allocation
LinuxC编程——ls的实现（-R,-a,-l）
dream0130__的博客
07-28 5192
Linux下的系统编程指的是程序员使用系统调用或C语言本身所携带的库函数来设计和编写某一特定的程序 ls是日常所用的比较常见的命令之一,那么如何实现ls命令 首先实现ls要明确参数的作用是什么 ls -a 可以将目录中的所有文件（包括以.开头的文件）显示出来 ls -l 列出文件中的所有信息，包括文件的属性和权限等数据 ls -R 使用递归连同目录中的子目录中的文...
实现自己的ls
qq_43646576的博客
07-23 231
相信在linux上最常用的命令之一应该就是ls了,因为我们可能随时都要知道文件或者目录的相关信息,而小组暑假留校的第一个小项目就是完成自己的ls,最终自己实现的ls具有-a,-l,-R,-r,-d以及染色输出不同权限的文件或是目录. 自己觉得需要注意的 1.在动手实现项目前自己要有一个大体的架构(我开始是依照书上的架构进行的,但越往后写自己会添加更多的功能,而且每个人的编程风格可能会存在一些差异,...
用c语言实现Linux命令ls操作
你听得到
05-16 8185
主要的流程是解析输入和调用相关的函数获得文件详细信息。 能够实现的命令格式有：ls –l (-d –R –a –I –al -ai) [filename1]([filename2] ……)。 演示效果如图所示： 代码如下： #include #include #include #include #include #include #include #inclu
linux系统编程实现ls -l 命令
最新发布
06-03
实现ls -l命令的关键是要读取当前目录下的文件和文件夹的信息，并将其格式化输出。下面是一个简单的C语言程序，实现了类似于ls -l的功能： ```c #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <dirent.h> #include <sys/stat.h> #include <unistd.h> #include <pwd.h> #include <grp.h> #include <time.h> int main(int argc, char *argv[]) { DIR *dp; struct dirent *entry; struct stat statbuf; struct passwd *pwd; struct group *grp; char date[20]; if ((dp = opendir(".")) == NULL) { fprintf(stderr, "Cannot open directory.\n"); exit(1); } while ((entry = readdir(dp)) != NULL) { if (entry->d_name[0] == '.') continue; if (lstat(entry->d_name, &statbuf) < 0) continue; printf((S_ISDIR(statbuf.st_mode)) ? "d" : "-"); printf((statbuf.st_mode & S_IRUSR) ? "r" : "-"); printf((statbuf.st_mode & S_IWUSR) ? "w" : "-"); printf((statbuf.st_mode & S_IXUSR) ? "x" : "-"); printf((statbuf.st_mode & S_IRGRP) ? "r" : "-"); printf((statbuf.st_mode & S_IWGRP) ? "w" : "-"); printf((statbuf.st_mode & S_IXGRP) ? "x" : "-"); printf((statbuf.st_mode & S_IROTH) ? "r" : "-"); printf((statbuf.st_mode & S_IWOTH) ? "w" : "-"); printf((statbuf.st_mode & S_IXOTH) ? "x" : "-"); printf(" %2lu", statbuf.st_nlink); if ((pwd = getpwuid(statbuf.st_uid)) != NULL) { printf(" %s", pwd->pw_name); } else { printf(" %d", statbuf.st_uid); } if ((grp = getgrgid(statbuf.st_gid)) != NULL) { printf(" %s", grp->gr_name); } else { printf(" %d", statbuf.st_gid); } strftime(date, 20, "%b %d %H:%M", localtime(&statbuf.st_mtime)); printf(" %s", date); printf(" %s\n", entry->d_name); } closedir(dp); return 0; } ``` 这个程序使用了许多系统调用和库函数，比如opendir、readdir、lstat、getpwuid、getgrgid等等。它首先打开当前目录（"."），然后循环读取目录下的每个文件和文件夹的信息，使用lstat函数获取文件的详细信息，再利用各种库函数将这些信息格式化输出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值