ptr[-1]的作用和用法

今天在看ＡＰＵＥ中４.７遍历目录程序的时候，发现一个语句　ptr[-1]=0; 这个用法很巧妙。

ptr[-1]其实表示的是ptr指针当前指向的上一个元素。指针名可当作数组名来用，在用作数组时，实际上是读取数组名，也就是一个地址，加上一个偏移地址。这个偏移地址的计算是就是：下标的值*元素类型的大小。这样就可打到要取得数的位置，不会判断下标是否是负数。

下面看一个例子：

#include <stdio.h>
 int add(int *a,int *b){
    printf("a=%d, b=%d\n",*a,*b);
    printf("a[-1]=%d, a[0]=%d,a[1]=%d\n",(a[-1]),a[0],a[1]);
    printf("b[-1]=%d, b[0]=%d,b[1]=%d\n",(b[-1]),b[0],b[1]);
 }

 int main(void){
     int a=2,b=3;
     add(&a,&b);
 }

程序的输出结果是：

aaron@aaron:~/Documents/clearning$ ./a.out 
a=2, b=3
a[-1]=0, a[0]=2,a[1]=3
b[-1]=2, b[0]=3,b[1]=134513824

因为，gcc 对局部变量a,b是按顺序分配的，这样通过适当的偏移值就可访问变量。

而对于ＡＰＵＥ中的程序的用法，ptr的作用是递归深入时，加下一层的路径，当递归返回时，减去下一层的路径。　

附程序：

/*************************************************************************
	> File Name: 4_7TranverseDir.c
	> Author: aaron
	> Mail: haojunzhan@gmail.com 
	> Created Time: Tue 18 Feb 2014 10:56:44 AM CST
    递归降序遍历目录层次结构，并按文件类型计数。
 ************************************************************************/

/* funciton type that is called for each filename */
#include "apue.h"
#include <dirent.h>
#include <limits.h>

typedef int Myfunc(const char *, const struct stat *,int);

static Myfunc myfunc;
static int    myftw(char *, Myfunc *);
static int    dopath(Myfunc *);

static long   nreg, ndir, nblk, nchr, nfifo, nslink, nsock, ntot;

int main(int argc,char *argv[]){
    int ret;
    
    if(argc!=2)
        err_quit("usage: ftw <starting-pathname>");
    ret=myftw(argv[1],myfunc);   // do it all 

    ntot=nreg+ndir+nblk+nchr+nfifo+nslink+nsock;
    if(ntot==0){
        ntot=1;     //avoid divide by 0; print 0 for all counts 
    }
    printf("regualr files =%7ld, %5.2f%%\n",nreg, nreg*100.0/ntot);
    printf("directories   =%7ld, %5.2f%%\n",ndir, ndir*100.0/ntot);
    printf("block special =%7ld, %5.2f%%\n",nblk, nblk*100.0/ntot);
    printf("char special  =%7ld, %5.2f%%\n",nchr, nchr*100.0/ntot);
    printf("FFIO          =%7ld, %5.2f%%\n",nfifo, nfifo*100.0/ntot);
    printf("symbolic links=%7ld, %5.2f%%\n",nslink, nslink*100.0/ntot);
    printf("sockets       =%7ld, %5.2f%%\n",nsock,nsock*100.0/ntot);
    exit(ret);
}

/* Descend through the hierarchy, starting at "pathname".
 * The caller's func() is called for every file.
 */
#define FTW_F  1        /* file other than directory */ 
#define FTW_D  2        /* directory */ 
#define FTW_DNR 3      /* directory that can't be read */ 
#define FTW_NS  4       /* file that we can't stat*/ 

static char *fullpath;         /* contains full pathname for every file */

static int myftw(char *pathname, Myfunc *func){
    int len;
    fullpath=path_alloc(&len);              /* malloc's for PATH_MAX+1 bytes */
    strncpy(fullpath,pathname,len);         /* protect against */
    fullpath[len-1]=0;                      /* buff overrun */

    return(dopath(func));
}
/*
 * Descend through the hierarchy, starting at "fullpath".
 * If "fullpath" is anything other than a directory, we lstat() it,
 * call func(), and return. For a directory, we call ourself 
 * recursively for each name in the directory.
 */

 /*we return whatever func( ) returns */
 static int dopath(Myfunc* func){
    struct stat     statbuf;
    struct dirent   *dirp;
    DIR             *dp;
    int             ret;
    char            *ptr;
    
    if(lstat(fullpath, &statbuf)<0)                    //stat error
        return (func(fullpath,&statbuf,FTW_NS));
    if(S_ISDIR(statbuf.st_mode)==0)                     // not a directory.
        return (func(fullpath,&statbuf,FTW_F));

/*
 * It's a directory. First call func() for the directory,
 * then process each filename in the directory.
 */
    if((ret=func(fullpath,&statbuf,FTW_D))!=0)                                 
        return(ret);
    ptr=fullpath+strlen(fullpath);                      // point to end of fullpath.
    *ptr++='/';
    *ptr=0;

    if((dp=opendir(fullpath))==NULL)                /* can't read directory */
        return(func(fullpath, &statbuf, FTW_DNR));
    
    while((dirp=readdir(dp))!=NULL){
        if(strcmp(dirp->d_name,".")==0||strcmp(dirp->d_name,"..")==0){
            continue;
        }

        strcpy(ptr,dirp->d_name);               //append name after slash

        if((ret=dopath(func))!=0)               // recursively
            break;
    }
    ptr[-1]=0;                              // erase everything from slash onwards 
    if (closedir(dp)<0)        
        err_ret("can't close directory %s", fullpath);
    return (ret);        
 }
 
static int myfunc(const char *pathname, const struct stat *statptr, int type){
    switch(type){
        case FTW_F:
        switch(statptr->st_mode & S_IFMT){
            case S_IFREG:  nreg++;  break;
            case S_IFBLK:  nblk++;  break;
            case S_IFCHR:  nchr++;  break;
            case S_IFIFO:  nfifo++;  break;
            case S_IFLNK:  nslink++;  break;
            case S_IFSOCK:  nsock++;  break;
            case S_IFDIR: 
                err_dump("for S_IFDIR for %s", pathname);   // directories should have type=FTW_D */
        }
        break;
        
        case FTW_D:
            ndir++;
            break;

        case FTW_DNR:
            err_ret("can't read directory %s", pathname);
            break;

        case FTW_NS:
            err_ret("stat error for %s", pathname);
            break;
        default:
            err_dump("unknown type %d for pathname %s", type, pathname);
    }
    return 0;
}
char *path_alloc(int* size)
{
    char *p = NULL;
    if(!size) return NULL;
    p = malloc(256);
    if(p)
    *size = 256;
    else
    *size = 0;
    return p;
}