typedef用于函数定义的一个例子

 typedef用于定义基本类型或者结构体，很简单

再看看怎么定义函数：

不使用typedef的：

#include <iostream>
using namespace std;

double besty(int);
double pam(int);
void estimate(int, double (*pf)( int ));

int main(void)
{
 int code;
 cout<<"How many lines of code do you need ?"<<endl;
 cin >>code;
 cout<<"Here is the besty's estimate!"<<endl;
 estimate(code,besty);
 cout<<"Here is the pam's estimate!"<<endl;
 estimate(code,pam);
 return 0;
}

double besty(int lns)
{
 return 0.5*lns;
}

double pam(int lns)
{
 return 0.03*lns+0.0004*lns*lns;
}

void estimate(int lines,double (*pf)(int))
{
 cout<<lines<<"line will take!"<<endl;
 cout<<(*pf)(lines)<<"hours"<<endl;
}

使用typedef的：

#include "stdafx.h"
#include <iostream>
using namespace std;

typedef double MM(int);

MM besty;
MM pam;
void estimate(int , MM *pf);

int main(void)
{
 int code;
 cout<<"How many lines of code do you need ?"<<endl;
 cin >>code;
 cout<<"Here is the besty's estimate!"<<endl;
 estimate(code,besty);
 cout<<"Here is the pam's estimate!"<<endl;
 estimate(code,pam);
 return 0;
}

double besty(int lns)
{
 return 0.5*lns;
}

double pam(int lns)
{
 return 0.03*lns+0.0004*lns*lns;
}

void estimate(int lines,MM *pf)
{
 cout<<lines<<"line will take!"<<endl;
 cout<<pf(lines)<<"hours"<<endl;
 cout<<(*pf)(lines)<<"hours"<<endl;//使用pf()和(*pf)()效果是一样的，在引用函数的时候，这两者表示一个意思。
}

再estimate函数里面要把参数里面的函数定义成double (*pf)(int)也就是指向函数的指针。

因为只有这种函数才可以被其他的函数（同返同参）赋地址。

比如

double (*pf)(int)；

double dd(int)；

double cc(int)；

pf＝dd；是可以的可以被赋地址。

cc＝dd；不可以。

同样在使用的时候上面的程序里面也带了说明，使用pf()和(*pf)()效果是一样的，在引用函数的时候，这两者表示一个意思。

就这个认识的也是有两个流派的，不过，现在两种都认为是对的，兼而容之！

 

 

今天修改一下，今天看到一个很不错的程序，linux下面的对目录进行访问的一个程序，里面typedef定义了的部分就很多。看看一下，typedef int Myfunc(const char *, const struct stat *, int);如果再使用Myfunc定义一个变量，那么其实就是定义了一个函数，表现的只是一个地址形式而已，这个函数具有Myfunc函数的所有参数以及返回类型！

看程序吧：

#include "apue.h"
#include <dirent.h>
#include <limits.h>

/* function type that is called for each filename */
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);  /* does 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("regular 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("FIFOs          = %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     /* we return whatever func() returns */
myftw(char *pathname, Myfunc *func)
{
 int len;
 fullpath = path_alloc(&len); /* malloc's for PATH_MAX+1 bytes */
         /* ({Prog pathalloc}) */
 strncpy(fullpath, pathname, len); /* protect against */
 fullpath[len-1] = 0;    /* buffer 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.
 */
static int     /* we return whatever func() returns */
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;  /* ignore dot and dot-dot */

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

  if ((ret = dopath(func)) != 0)  /* recursive */
   break; /* time to leave */
 }
 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);
}