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);
}