LinuxC编程——ls的实现（-R,-a,-l）

曾经终败给现在 2022-05-18 02:21 206阅读 0赞

###### Linux下的系统编程指的是程序员使用系统调用或C语言本身所携带的库函数来设计和编写某一特定的程序 ######

ls是日常所用的比较常见的命令之一,那么如何实现ls命令  
首先实现ls要明确参数的作用是什么

> ###### ls -a 可以将目录中的所有文件（包括以.开头的文件）显示出来 ######
> 
> ###### ls -l 列出文件中的所有信息，包括文件的属性和权限等数据 ######
> 
> ###### ls -R 使用递归连同目录中的子目录中的文件显示出来，如果要显示隐藏文件就要添加-a参数 ######

在实现ls之前我们需要了解如下的信息  
用户权限所对应的表

<table> 
 <thead> 
  <tr> 
   <th>字符长量值</th> 
   <th align="center">字符常量对应的八进制值</th> 
   <th align="right">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>S_IRUSR(S_IREAD)</td> 
   <td align="center">00400</td> 
   <td align="right">文件所有者具有可读权限</td> 
  </tr> 
  <tr> 
   <td>S_IWUSR(S_IWRITE)</td> 
   <td align="center">00200</td> 
   <td align="right">文件所有者具有可写入权限</td> 
  </tr> 
  <tr> 
   <td>S_IXUSR(S_IEXEC)</td> 
   <td align="center">00100</td> 
   <td align="right">文件所有者具有可执行权限</td> 
  </tr> 
  <tr> 
   <td>S_IRGRP</td> 
   <td align="center">00040</td> 
   <td align="right">用户组具有可读取权限</td> 
  </tr> 
  <tr> 
   <td>S_IWGRP</td> 
   <td align="center">00020</td> 
   <td align="right">用户组具有可写入权限</td> 
  </tr> 
  <tr> 
   <td>S_IXGRP</td> 
   <td align="center">00010</td> 
   <td align="right">用户组具有可执行权限</td> 
  </tr> 
  <tr> 
   <td>S_IROTH</td> 
   <td align="center">00004</td> 
   <td align="right">其他用户具有可读权限</td> 
  </tr> 
  <tr> 
   <td>S_IWOTH</td> 
   <td align="center">00002</td> 
   <td align="right">其他用户具有可写入权限</td> 
  </tr> 
  <tr> 
   <td>S_ISUID</td> 
   <td align="center">04000</td> 
   <td align="right">文件的 (set user-id)位</td> 
  </tr> 
  <tr> 
   <td>S_ISGID</td> 
   <td align="center">02000</td> 
   <td align="right">文件的(set group-id)位</td> 
  </tr> 
  <tr> 
   <td>S_ISVTX</td> 
   <td align="center">01000</td> 
   <td align="right">文件的 sticky位</td> 
  </tr> 
 </tbody> 
</table>

在ls的输出过程中，需要粗略的计算终端的宽度,在这里我介绍的是isatty和ioctl函数

> ###### isatty函数是用来判断目前所输出的设备是不是为终端设备 ######
> 
> ###### ioctl可以获得终端的设备信息，一些特殊的设备文件都可以利用这个来获得 ######

具体用法如下:(在这个用法中，我将 terminalWidth 作为全局变量

void getWidth(){
        struct winsize wbuf;
        terminalWidth = 80;
        if( isatty(STDOUT_FILENO) ){
           if(ioctl(STDOUT_FILENO, TIOCGWINSZ, &wbuf) == -1 || wbuf.ws_col == 0){
            return ;  
            }
            else
                terminalWidth = wbuf.ws_col;
        }
    
    }

我们还应该了解如何获得文件的属性

> \#include < sys/types.h>  
> \#include < sys/stat.h>  
> \#include < unistd.h>  
> int stat(const char \*pathname, struct stat \*statbuf);  
> int fstat(int fd, struct stat \*statbuf);  
> int lstat(const char *pathname, struct stat \*statbuf);\**

很多小伙伴们肯定对应该使用哪个函数感到迷惑，这三个函数的区别为， stat 用于获取由参数file name 所指定的文件名信息，保存在struct stat \* buf 中，fstat 与 stat 的区别 fstat 是通过文件描述符来制定文件的， lstat 与 stat 的区别在于，对于 符号链接文件 , lstat 返回的是 符号链接本身， 而stat 指向的是文件状态信息

2。所以我在这里推荐大家是用的是，lstat 这个函数, 而对于如何读取链接文件，在这里我们可以使用 readlink 这个函数 来获取 文件中的链接  
我在这里还遇到了一些错误,首先来跟大家说说readlink 这个函数应该如何应用  
这个函数既是shell中的命令，又是操作系统提供的接口  
通过查阅man 手册我们可以看到

> \#include < unistd.h>  
> ssize\_t readlink(const char \*pathname, char \*buf, size\_t bufsiz);  
> \#include < fcntl.h> /\* Definition of AT\_\* constants \*/  
> \#include < unistd.h>  
> ssize\_t readlinkat(int dirfd, const char \*pathname,  
> char \*buf, size\_t bufsiz);

首先它的返回值是ssize\_t类型 ，在32位的机器上 它与 int 类型是一致的，而在 64 位的机器上 它的类型与 long int 类型是一致的  
它可以读取目录中的内容但是它不以文件控制符号来结尾’\\0’,也就是说必须得添加’\\0’才能使用  
我在实现readlink的过程中遇到了如下的错误:

> 1.没有添加’\\0’导致每次输出自己所读取的链接就会遇到段错误，即访问了不该访问的内存  
> 2.我采用的是动态数组,动态数组是在堆中申请的，而内核为了方便效率，在申请的动态数组中是有内容的，所以在使用的过程中动态数组必须进行初始化，不然就会读取其他很多不相干的内容

在 struct stat \* buf 中是一个保存文件信息的结构体

> struct stat \{  
> dev\_t st\_dev;//文件的设备编号  
> ino\_t st\_ino;//文件的i-node编号  
> mode\_t st\_mode\_t//文件的类型和存取的权限  
> nlink\_t st\_nink;//文件的硬链接数目  
> uid\_t st\_uid;//文件所有者的id  
> gid\_t st\_gid//文件所有组的id  
> dev\_t st\_rdev;//若文件为设备文件,则为其设备编号  
> off\_t st\_size//文件的大小  
> blksize\_t st\_blksize//文件系统的缓冲区  
> blkcnt\_t st\_blocks//占有文件的区块的个数  
> time\_t st\_atime//文件最近一次被访问的时间  
> time\_t st\_mtime//文件最后一次被修改的时间  
> time\_t st\_ctime//文件最近一次被更改的时间

st\_mode所包含的文件信息

> S\_ISLNK 符号链接  
> S\_ISREG 一般文件  
> S\_\_ISDIR 目录文件  
> S\_ISCHR 为字符设备文件  
> S\_ISBLK 块设备文件  
> S\_ISFIFO 判断是不是为FIFO  
> S\_ISSOCK 判断是不是为 套接字

了解如何获取目录信息，只要对目录是由读的权限，就可以获取目录信息

> 1.opendir  
> DIR *opendir(const char*  name)  
> 用来获取参数指定的目录，并且返回DIR\*的目录流，类似与文件操作中的文件描述符，接下来对目录的读取和搜索都要使用此返回值，成功则返回DIR \* 的目录流  
> 2.readdir  
> 用来从DIR中读取中目录项信息，类似于链表的遍历输入完成后输出NULLd\_name  
> 3.closedir  
> 关闭dir所指向的目录  
> 用法如下  
> \#include< sys/types.h>  
> \#include< dirent.h>  
> \#include < stdio.h>  
> int readir(const char \* path)  
> \{  
> DIR \* dir;  
> struct dirent \* prt;  
> if((dir = opendir(path)==NULL)  
> perror(“opendir”);  
> while((ptr=readdir(dir)!=NULL)  
> \{  
> printf(“%d” ptr->d\_name);  
> \}  
> closedir(dir);  
> return 0;  
> \}

在实现递归的过程中，可以采用 **rewinddir 函数 十分重要**  
在这里我将解释以下 rewinndir的函数作用，以及为什么它在递归的过程中相当重要  
头文件：

> \#include < sys/types.h>  
> \#include < dirent.h>

定义的函数:

> void rewinddir(DIR \*dir);

官方给出的说明是rewinddir()用来设置参数dir 目录流目前的读取位置为原来开头的读取位置.  
可以这么理解，打印出上级目录的时候已经进入到当前目录的最后一个，使用rewinddir就可以返回第一个文件中  
我在实现 ls -R 遇到的问题即自己的解决办法

> 1.遭遇段错误  
> 可能原因：栈溢出  
> \-R 递归会产生巨大的文件量，使用普通的静态数组是无法满足这种需求，即使范围在大也不可以，在这里我们应该使用 动态数组或者 链表 来实现这个功能  
> 2.在遍历/proc/目录的过程中偶尔会遭遇错误，大部分情况可以实现  
> 可能原因：文件读取失败  
> 解决方式； lstat 来获取文件信息如果获取失败就返回上层  
> /proc/是虚拟文件系统，它在里面保存进程，并且会定期清除,可能在读取的同时，和删除这个文件，即读取失败

在实现ls -R 的时候一定要明确自己思路  
我的思路是，先输出第一层目录，然后通过rewinddir 返回到文件流，然后判断它是不是目录，如果是目录则进入,当一层没有目录的时候，就return 返回上层  
代码奉上

#include <sys/types.h>
    #include <sys/stat.h>
    #include <unistd.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <pwd.h>
    #include <grp.h>
    #include <time.h>
    #include <dirent.h>
    #include<stdlib.h>
    #include<sys/ioctl.h>
    int terminalWidth ;
    char filenames[256][PATH_MAX];
    char filenames1[256][100];
    int alfag=0,lflag=0;//参数种类,对-l和-a,-r,-R进行判断
    int cnt=0;
    void Quicksort(int cnt1,char filenames2[][PATH_MAX],int start);
    void recursion(char * path,int alfag);
    int ls_prepare(char *path,int lflag);
    int ls_prepare(char *pathname,int lflag);
    int _ls(char *path,int lflag,int alfag);
    int colormode,foreground,background;    
    void getcolor( char *filename ){
        struct stat info;    //通过设置可以获取文件属性
        foreground=0;
       lstat( filename,&info );//将文件输入获得赋值给info
    //    foreground = 37;
        switch ( (info.st_mode & S_IFMT) ){
            case S_IFREG:               /*regular 普通文件 , 色*/
                {
                    foreground = 37;
                        if((info.st_mode&S_IXOTH)||(info.st_mode&S_IXGRP)||(info.st_mode&S_IXUSR))
          {
                foreground = 32;
            }
                break;
                }
            case S_IFLNK:               /*symbolic link 链接文件 , 青蓝色*/
                foreground = 36;
                break;
            case S_IFSOCK:              /*紫红色*/
                foreground = 35;
                break;
            case S_IFDIR:               /*directory 目录文件 , 蓝色*/
            foreground = 34;
                break;
            case S_IFBLK:               /*block special 块设备文件 , 黄色*/
                foreground = 33;
                break;
            case S_IFCHR:               /*character special 字符设备文件 , 黄色*/
                foreground = 33;
                break;
        }
    }
    struct filename
    {
        char filename[PATH_MAX];
        struct filename * next;
    };
    void Quicksort1(struct filename * pHead,struct filename * tail)
    {
        if(pHead->next==tail)
            return ;
        if(pHead->next->next==tail)
        {
                return ;
        }
        struct filename * mid = pHead->next;
        struct filename * p = pHead;
        struct filename * q =mid;
        struct filename * t = mid->next;
        char name[MAXNAMLEN];
        strcpy(name,mid->filename);
        while(t!=tail)
        {
            if(strcmp(t->filename,name)<0)
                p=p->next=t;
            else
                q=q->next=t;
            t=t->next;
        }
        p->next= mid;
        q->next =tail;
        Quicksort1( pHead ,mid );
        Quicksort1( mid  , tail);
    }
    void list_R(const char * dirname,int lflag)
    {
            DIR     *dir_ptr;       
            struct dirent   *direntp;       
            char        *fullpath;
            struct stat info;
    //        int i;
            struct filename * pHead,*p1;
            pHead=p1=(struct filename *)malloc(sizeof(struct filename));
            pHead->next=p1->next=NULL;
            printf("%s:\n",dirname);
            if ( ( dir_ptr = opendir( dirname ) ) == NULL ){
                fprintf(stderr,"list_R: cannot open %s\n", dirname);
                return;
            }
         //  printf("%s:\n",dirname);
    //        i=0;
            fullpath = (char *)malloc(strlen(dirname) + 1 + MAXNAMLEN + 1);
            while ( ( direntp = readdir( dir_ptr ) ) != NULL )
            {   
                struct filename *new1=(struct filename *)malloc(sizeof(struct filename));
                if(alfag==0)
               { 
                if(direntp->d_name[0]=='.')
                {
                    continue;
                }
              }          
    
                 sprintf(fullpath,"%s/%s",dirname,direntp->d_name);
             if(lflag==3)
                 _ls(fullpath,lflag,alfag);
                 else
                 {
                       strcpy(new1->filename,direntp->d_name);
                       p1->next=new1;
                       p1=new1;
                       new1->next=NULL;
                }
            }
            Quicksort1(pHead,NULL);
           struct filename *  pTemp=pHead->next;
            struct filename * q=pHead;
            if(pHead->next!=NULL)
            {
                while(pTemp!=NULL)
            {
                getcolor(pTemp->filename);
                printf("\033[%dm%s\033[0m\n",foreground,pTemp->filename);
                free(q); 
                q=pTemp;
                pTemp=pTemp->next;
            }
            }
            if ( lflag ){
                rewinddir(dir_ptr);
                while ( ( direntp = readdir( dir_ptr ) ) != NULL )
                {
                 if(alfag==0)
              { 
                  if(direntp->d_name[0]=='.')
                 {
                   continue;
                 }
               }
                    sprintf(fullpath,"%s/%s",dirname,direntp->d_name);
                //                printf("%s",direntp->d_name);
               //   puts("");
                   lstat(fullpath,&info);
            //       _ls(fullpath,lflag,alfag);
            if(alfag==0)
            {
                if(S_ISDIR(info.st_mode))
                      {
                            putchar('\n');
                            list_R( fullpath, lflag );
                        }
            }
            else
            {
                if ( S_ISDIR(info.st_mode)&& direntp->d_name[0]!='.')
                        //
                         {
                        putchar('\n');
                        list_R( fullpath, lflag );
                    }
                 }
            }
            }
            closedir(dir_ptr);
            free(fullpath);
        }
    void Quicksort(int cnt1,char filenames2[][PATH_MAX],int start)
    {
        int i,j;
        char *name;
        char *name1;
        name=(char *)malloc(MAXNAMLEN);
        name1=(char *)malloc(MAXNAMLEN);
        memset(name,0,MAXNAMLEN);
        memset(name,0,MAXNAMLEN);
        if(start >cnt1)
            return ;
        strcpy(name,filenames2[start]);
        i=start;
        j=cnt1;
        while(i!=j)
        {
            while(strcmp(filenames2[j],name)<=0 && i<j)
                j--;
            while(strcmp(filenames2[i],name)>=0 && i<j)
                i++;
            if(i<j)
            {
                    strcpy(name1,filenames2[i]);
               strcpy(filenames2[i],filenames2[j]);
                strcpy(filenames2[j],name1);
          }
        }
        strcpy(filenames2[start],filenames2[i]);
        strcpy(filenames2[i],name);
           Quicksort(i-1,filenames2,start);
           Quicksort(cnt1,filenames2,i+1);
           return ;
           free(name);
           free(name1);
    }
    void getWidth(){
        struct winsize wbuf;
        terminalWidth = 80;
        if( isatty(STDOUT_FILENO) ){
            if(ioctl(STDOUT_FILENO, TIOCGWINSZ, &wbuf) == -1 || wbuf.ws_col == 0){
            }
            else
                terminalWidth = wbuf.ws_col;
        }
        return ;
    }
    int getlen_str(char * str)
    {
        int res=0,i;
        while(*str!='\0')
        {
            if(*str > 0)
            {
                res++;
                str++;
            }
            else
            {
                for(i=7;i>=0;i--)
                {
                    if(!((*str>>7)&1))
                        break;
                    res+=2;
                    str+=7-i;
                 //   if((*str>>7)&1)
                //        break;
                }
            }
        }
        return res;
    }
    void display_single(int cnt,int alfag)
    {
        int i,k,n=0,m=0,j=0,n1;
       n=cnt,n1=cnt;
       i=0;
      Quicksort(cnt,filenames,0);
        while(n>=0)
        {
            n--;
            strcpy(filenames1[i],filenames[i]);
            for(m=0;m<((int)strlen(filenames[i]));m++)
            {
    
                if((filenames[i][m]=='.'&&filenames[i][m-1]=='/'))
                 {   
                     break ;
                 }
                 if(filenames[i][m]=='/')
                 {
                     k=m;
               }
            }   
                  for(j=0;j<=k;j++)
               {
                   filenames[i][j]=' ';
                }
                                      if(alfag==0)
                         {
    
                           if(filenames[i][k+1]=='.')
                           {
                                    strcpy(filenames[i]," ");
                            }
                         }
            i++;
        }
        Quicksort(cnt,filenames,0);
        int wordColNUM=20;
         cnt=cnt<wordColNUM?cnt:wordColNUM;//列
        while(cnt>0)
        {  int wordLenMax[4000]={
       0};//窗口的长度
          int wordRowNum=0;//窗口的行
          j=0;
          int sum=0;
          int length[4000];
          for(j=0;j<n1;j++)
          {
              length[j]=getlen_str(filenames[j]);
          }
         wordRowNum=(n1%cnt)?(n1/cnt):(n1/cnt+1);//行
         if((cnt-1)*wordRowNum>=terminalWidth)
             cnt-- ;
         for(j=0;j<cnt;j++)
         {
             int f=j*wordRowNum;
             for(i=0;i<wordRowNum;i++)//求出行数最宽的是
          {
              if(f>n1)
                  break;
              if(getlen_str(filenames[f])>wordLenMax[j])
                  wordLenMax[j]=(getlen_str(filenames[f]));
              f++;
          }
             if(j!=cnt-1)
             sum+=wordLenMax[j]+2;
         }
         if(sum<terminalWidth)
         {
           //  cnt--;
             int t=wordRowNum - cnt * wordRowNum +n1;
             for(int p=0;p<wordRowNum;p++)
             {
                 for(int o=0;o<cnt-1;o++)
                 {
                   getcolor(filenames1[p+o*wordRowNum]);
                     printf("\033[%dm%s\033[0m",foreground,filenames[p+o*wordRowNum]);
                     for(int y=0;y<wordLenMax[o]-length[p+o*wordRowNum];y++)
                     printf(" ");
                     for( int g=0;g<2;g++)
                        printf(" ");
              //   printf("\n");
                }
                 if(t)
                 {
                     getcolor(filenames1[p+(cnt-1 )*wordRowNum]);
                     printf("\033[%dm%s\033[0m",foreground,filenames[p+(cnt-1)*wordRowNum]);
                     t--;
                 }
                 printf("\n");
             }            
             break;
         }
     //     wordLenMax +=2; //空格防止一组由多行输出;
     //     wordRowNum = terminalWidth/wordLenMax;    //面积除宽等于列的长度
         cnt--;
         if(!cnt)
         {
             cnt=1;
             for(int x=0;x<n;x++)
             {
                 getcolor(filenames1[x]);
                 printf("\033[%dm%s\033[0m\n",foreground,filenames[x]);
    
             }
         }
        }
          return ;
    }
    int _ls(char *path,int lflag,int alfag)
    {
        int i,n,k;
        int  temp;
        struct stat buf;
        char *out=NULL;
    //   char out[PATH_MAX];
        struct passwd *pw=NULL;
        struct group *gr=NULL;
        char *t=NULL;
        char *name=NULL;
        char *name1=NULL;
          name = (char *)malloc(strlen(path) + 1 + MAXNAMLEN + 1);
          name1 =(char *)malloc(strlen(path)+1 +MAXNAMLEN +1);
          out=(char *)malloc(PATH_MAX);
            memset(out,0,PATH_MAX);
       //   j=strlen(out);
        strcpy(name,path);
        strcpy(name1,path);
        for(i=0;i<((int)strlen(name));i++)
        {
             if((name[i]=='.'&&name[i-1]=='/')&&alfag==0)
             {   // cnt--;
                 return 0;
             }
             if(name[i]=='/')
                k=i;
        }
        for(i=0;i<=k;i++)
        {
             name[i]=' ';     
        }
        if(lflag==2)
            return 0;
       // lstat(path,&buf);
        if(lstat(path,&buf)<0)
        {
        //  fprintf(stderr,"stat error:%s\n",strerror(errno));
            return 0 ;
        }
        //获取字符串的属性：普通文件-、目录d、字符设备c、块设备b、
        //管道文件p、连接文件l、套接字文件s
        //st.mode表示的是文件的权限和文件的用户
            switch(buf.st_mode & S_IFMT)        //S_IFMT表示位遮罩
        {
        case S_IFREG:   
            {
                printf("-");
            }
            break;
        case S_IFDIR:   
            {
                printf("d");
            }
            break;
        case S_IFCHR:   
            {
                printf("c");
            }
            break;
        case S_IFBLK:   
            {
                printf("b");
            }
            break;
        case S_IFIFO:   
            {
                printf("p");
            }
            break;
        case S_IFLNK:   
            {
                printf("l");
            }
            break;
        case S_IFSOCK:  
            {
                printf("s");
            }
            break;
        }
        //打印文件的读写属性：读r、写w、执行x、无权限-
        for(n=8;n>=0;n--)       
        {
            if(buf.st_mode&(1<<n))
            {
                switch(n%3)
                {
                case 2:
                    printf("r");
                    break;
                case 1:
                    printf("w");
                    break;
                case 0:
                    {
                        printf("x");
                    }
                        break;
                default:
                    break;
                }
            }
            else
            {
                printf("-");
            }
        }
    
        //硬链接数，此链接非彼链接，指（包含）目录的个数，
        //文件为1，目录起始为2，再加上目录里包含的目录个数（不递归，只一层）
        printf(" %4d ",(int)buf.st_nlink);      
        pw = getpwuid(buf.st_uid);      //所属用户名//可以得到用户指定的信息
                     //根据struct passswd * getpwuid来进行判断
            printf(" %s ",pw->pw_name);     
    
    
        gr = getgrgid(buf.st_gid);      //所属组名
        printf(" %6s ",gr->gr_name);
        printf(" %8ld ",buf.st_size);       //字节计总大小
        t = ctime(&buf.st_atime);   //最后一次访问时间
         printf(" %10.12s ",4+t);
         getcolor(path);
                   printf("\033[%dm%4s\033[0m",foreground,name);
        //判断是否为链接，是返回真   
        if(S_ISLNK(buf.st_mode))        
        {
                 printf(" -> "); 
            if((temp=readlink(name1,out,PATH_MAX)==-1))//读取链接数失败
            {
            //  printf("readlink error");
            }
            strcat(out,"\0");
            printf("%4s",out);
        }
        printf("\n");
        free(name);
        free(name1);
        free(out);
        return 0;
    }
    // ls的准备工作
    int ls_prepare(char *path,int lflag)        
    {
        struct stat buf;        //man lstat可以看到此结构
        DIR *dir;       //opendir会返回一个类似于dir的数据流
        struct dirent *ptr;
        int count = 0;
        //man readdir可以看到此结构
        //获取文件/目录属性并赋值给buf，该函数和lstat一样，
        //只是当w为链接时，指代他本身，并不存在文件
    lstat(path,&buf);
        /*  if(lstat(path,&buf)<0)      
        {
            fprintf(stderr,"stat error:%s\n",strerror(errno));
            return -1;
        }*/
        dir=opendir(path);
        while((ptr= readdir(dir))!=NULL)
        {
                count++;
        }
        closedir(dir);
         int i,len=strlen(path);
         dir=opendir(path);
         for(i=0;i<count;i++)
         {
             ptr=readdir(dir);
             if(ptr==NULL)
             {
                 perror("readdir");
             }
             strcpy(filenames[i],path);
             filenames[i][len]='\0';
             strcat(filenames[i],ptr->d_name);
             filenames[i][len+strlen(ptr->d_name)]='\0';
         }
         cnt=i;
        //S_IRUSR表示读权限,S_IWUSR表示写权限 
      Quicksort(cnt-1,filenames,0);
        if(lflag==0)
        {
            display_single(cnt,alfag);
            return 0;
        }
            for(i=0;i<count;i++)
            {
                _ls(filenames[i],lflag,alfag);
        }
       closedir(dir);   
        return 0;
    }
    int main(int argc,char ** argv)
    {
       getWidth();
        char param[32];//用来保存命令行的参数,命令行的形式一般为 -l -al -a
       char path[81];
       struct stat buf;
       int i,j,k,num=0;
        //命令行中实现解析
        j=0;
       for(i=1;i<argc;i++)
       {
           if(argv[i][0]=='-')
           {
               for(k=1;k<(int)strlen(argv[i]);k++,j++)
               {
                    param[j] = argv[i][k];
               }
               num++;
           }
       }
      for(i=0;i<j;i++)
      {
            if(param[i]=='a')
            {
                alfag=1;
                continue;
            }
            if(param[i]=='l')
            {
              lflag+=1;
              continue;
            }
            if(param[i]=='R')
            {
                lflag=lflag+2;
                continue;
            }
      }
      param[j]='\0';
      //如果在其后没有输入文件名或者目录，默认为当前目录
      if((num+1)==argc)
      {
          strcpy(path,"./");
          path[2]='\0';
          ls_prepare(path,lflag);
          return 0;     
      }
      i=1;
      do
      {
          if(argv[i][0]=='-')
          {
              i++;
              continue;
          }
          else
          {
              strcpy(path,argv[i]);
              if(stat(path,&buf)==-1)
              {
                  perror("stat");
              }
              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';
                        if(lflag>=2)
                        {
                          list_R(path,lflag);
                           return 0;
                         }  
                            ls_prepare(path,lflag);
                            i++;
              }
              else{
                            display_single(cnt,alfag);
                            i++;
              }
          }
      }while(i<argc);
    return 0;
    }