一个关于APUE的例子的相关问题:函数变量指针相关？

vaqeteart

我在阅读apue的时候，遇到了一个问题，
这个例子是遍历目录的例子，源代码在
http://book.chinaunix.net/specia ... /ch04lev1sec21.html
为了方便阅读，我也贴上面了，如果格式不习惯，或者更多的信息参见前面的网址。
问题是，
1，myfunc是用typedef定义的函数类型的变量，那么，这个变量是否代表一个函数？
2，如果1成立，怎样引用myfunc所代表的函数？
3，在例子里面，把 myfunc作为其他函数的参数了，那么，myfunc本身的参数是从哪里传进来的？
总结如上问题，关键就是，如何获取myyfunc的参数信息？

1. #include "apue.h"
   
2. #include <dirent.h>
   
3. #include <limits.h>
   
4. 
   
5. /* function type that is called for each filename */
   
6. typedef int Myfunc(const char *, const struct stat *, int);
   
7. 
   
8. static Myfunc     myfunc;
   
9. static int        myftw(char *, Myfunc *);
   
10. static int        dopath(Myfunc *);
    
11. 
    
12. static long nreg, ndir, nblk, nchr, nfifo, nslink, nsock, ntot;
    
13. 
    
14. int
    
15. main(int argc, char *argv[])
    
16. {
    
17.     int     ret;
    
18. 
    
19.     if (argc != 2)
    
20.         err_quit("usage: ftw <starting-pathname>");
    
21. 
    
22.     ret = myftw(argv[1], myfunc);        /* does it all */
    
23. 
    
24.     ntot = nreg + ndir + nblk + nchr + nfifo + nslink + nsock;
    
25.     if (ntot == 0)
    
26.         ntot = 1;       /* avoid divide by 0; print 0 for all counts */
    
27.     printf("regular files  = %7ld, %5.2f %%\n", nreg,
    
28.       nreg*100.0/ntot);
    
29.     printf("directories    = %7ld, %5.2f %%\n", ndir,
    
30.       ndir*100.0/ntot);
    
31.     printf("block special  = %7ld, %5.2f %%\n", nblk,
    
32.       nblk*100.0/ntot);
    
33.     printf("char special   = %7ld, %5.2f %%\n", nchr,
    
34.       nchr*100.0/ntot);
    
35.     printf("FIFOs          = %7ld, %5.2f %%\n", nfifo,
    
36.       nfifo*100.0/ntot);
    
37.     printf("symbolic links = %7ld, %5.2f %%\n", nslink,
    
38.       nslink*100.0/ntot);
    
39.     printf("sockets        = %7ld, %5.2f %%\n", nsock,
    
40.       nsock*100.0/ntot);
    
41. 
    
42.     exit(ret);
    
43. }
    
44. 
    
45. /*
    
46. * Descend through the hierarchy, starting at "pathname".
    
47. * The caller's func() is called for every file.
    
48. */
    
49. #define FTW_F   1       /* file other than directory */
    
50. #define FTW_D   2       /* directory */
    
51. #define FTW_DNR 3       /* directory that can't be read */
    
52. #define FTW_NS  4       /* file that we can't stat */
    
53. 
    
54. static char *fullpath;      /* contains full pathname for every file */
    
55. 
    
56. static int                  /* we return whatever func() returns */
    
57. myftw(char *pathname, Myfunc *func)
    
58. {
    
59. 
    
60.     int len;
    
61.     fullpath = path_alloc(&len);    /* malloc's for PATH_MAX+1 bytes */
    
62.                                         /* (Figure 2.15) */
    
63.     strncpy(fullpath, pathname, len);       /* protect against */
    
64.     fullpath[len-1] = 0;                    /* buffer overrun */
    
65. 
    
66.     return(dopath(func));
    
67. }
    
68. /*
    
69. * Descend through the hierarchy, starting at "fullpath".
    
70. * If "fullpath" is anything other than a directory, we lstat() it,
    
71. * call func(), and return. For a directory, we call ourself
    
72. * recursively for each name in the directory.
    
73. */
    
74. static int                  /* we return whatever func() returns */
    
75. dopath(Myfunc* func)
    
76. {
    
77.     struct stat     statbuf;
    
78.     struct dirent   *dirp;
    
79.     DIR             *dp;
    
80.     int             ret;
    
81.     char            *ptr;
    
82. 
    
83.     if (lstat(fullpath, &statbuf) < 0) /* stat error */
    
84.         return(func(fullpath, &statbuf, FTW_NS));
    
85.     if (S_ISDIR(statbuf.st_mode) == 0) /* not a directory */
    
86.         return(func(fullpath, &statbuf, FTW_F));
    
87. 
    
88.      /*
    
89.       * It's a directory. First call func() for the directory,
    
90.       * then process each filename in the directory.
    
91.       */
    
92.     if ((ret = func(fullpath, &statbuf, FTW_D)) != 0)
    
93.         return(ret);
    
94. 
    
95.     ptr = fullpath + strlen(fullpath);      /* point to end of fullpath */
    
96.     *ptr++ = '/';
    
97.     *ptr = 0;
    
98. 
    
99.      if ((dp = opendir(fullpath)) == NULL)     /* can't read directory */
    
100.          return(func(fullpath, &statbuf, FTW_DNR));
     
101. 
     
102.      while ((dirp = readdir(dp)) != NULL) {
     
103.          if (strcmp(dirp->d_name, ".") == 0 ||
     
104.              strcmp(dirp->d_name, "..") == 0)
     
105.                  continue;        /* ignore dot and dot-dot */
     
106. 
     
107.          strcpy(ptr, dirp->d_name);   /* append name after slash */
     
108. 
     
109.          if ((ret = dopath(func)) != 0)          /* recursive */
     
110.               break; /* time to leave */
     
111.      }
     
112.      ptr[-1] = 0;    /* erase everything from slash onwards */
     
113. 
     
114.      if (closedir(dp) < 0)
     
115.          err_ret("can't close directory %s", fullpath);
     
116. 
     
117.      return(ret);
     
118. }
     
119. 
     
120. static int
     
121. myfunc(const char *pathname, const struct stat *statptr, int type)
     
122. {
     
123.     switch (type) {
     
124.     case FTW_F:
     
125.         switch (statptr->st_mode & S_IFMT) {
     
126.         case S_IFREG:    nreg++;    break;
     
127.         case S_IFBLK:    nblk++;    break;
     
128.         case S_IFCHR:    nchr++;    break;
     
129.         case S_IFIFO:    nfifo++;   break;
     
130.         case S_IFLNK:    nslink++;  break;
     
131.         case S_IFSOCK:   nsock++;   break;
     
132.         case S_IFDIR:
     
133.             err_dump("for S_IFDIR for %s", pathname);
     
134.                     /* directories should have type = FTW_D */
     
135.         }
     
136.         break;
     
137. 
     
138.     case FTW_D:
     
139.         ndir++;
     
140.         break;
     
141. 
     
142.     case FTW_DNR:
     
143.         err_ret("can't read directory %s", pathname);
     
144.         break;
     
145. 
     
146.     case FTW_NS:
     
147.         err_ret("stat error for %s", pathname);
     
148.         break;
     
149. 
     
150.     default:
     
151.         err_dump("unknown type %d for pathname %s", type, pathname);
     
152.     }
     
153. 
     
154.     return(0);
     
155. }
     

复制代码

tajial

回复 1# vaqeteart
typedef定义的是变量？
哥 你得好好学学了

liwangli1983

1，myfunc是用typedef定义的函数类型的变量，那么，这个变量是否代表一个函数？
myfunc是函数指针。
2，如果1成立，怎样引用myfunc所代表的函数？
myfunc(参数)，和普通函数一样。
3，在例子里面，把 myfunc作为其他函数的参数了，那么，myfunc本身的参数是从哪里传进来的？
接收myfunc做为参数的函数调用并赋予其参数，见84行对func的调用，func也是Myfunc类型的函数指针

vaqeteart

回复 2# tajial
看清楚些，我说的是“typedef定义的函数类型的变量”，
不过还是谢谢你

zhangsuozhu

都被他说了。我还说什么啊。2分得了。哈哈

pandaiam

求Own讲解typedef.

tempname2

这就是个缩写而已，当被缩写的函数作为另一个函数的参数时，那个函数的声明或者定义就会“好看”些。

看见识“不好看”的版本，参见信号那一章。