typedef关键字

typedef功能十分强大：

　　typedef声明有助于创建平台无关类型，甚至能隐藏复杂和难以理解的语法。

　　typedef与简单类型：

　　　　最简单的用法：typedef int size 这样声明了一个int的同义词size。

typedef char line[81];
line text = "content";

　　typedef与指针：

　　　　隐藏指针语法：typedef char* pstr 这样就可以用pstr来声明一个char*类型。

　　typedef与结构体：

　　　　定义一个结构体，如下：

struct MyPoint{
  float x;
  float y;          
};

　　　　声明一个结构体变量：

struct MyPoint point;

　　　　默认情况下，要带个struct关键字。

　　　　使用typedef struct MyPoint SPoint; 就可以直接使用SPoint p;来声明变量了。

　　typedef与函数指针：

typedef int (*sumFunc)(int, int);

int func(int a, int b)
{
     return a + b;
}

int main()
{
     sumFunc f = func;
     printf("%d
",(*f)(1, 2));
     return 0;
}

　　　　上面例子中声明了一个参数（int，int）->int类型的函数指针sumFunc;

　　typedef在《UNIX高级环境编程》4-22中：

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

　　　　给(const char*, const struct stat*,int)->int函数类型起了个别名：Myfunc。后期声明该类型函数指针的时候可以使用Myfunc *

/*********/

看到了一个很好的讲解地址在：这里

• 理解复杂的声明和定义
  

       在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义，例如：

        (1)  void * (* (*fp1) (int)) [10];

        (2)  float (* (*fp2) (int, int, float)) (int);

        (3)  typedef double (* (* (*fp3) ()) [10]) ();

               fp3 a;

        (4)  int (* (*fp4()) [10]) ();

        刚看到这些声明或者定义时，一些初学者甚至有一定经验的工程师都有可能头皮发毛，基于大惑不解。如果缺乏经验和方法来对这些内容进行理解，势必会让我们浪费大量的时间。

        我尝试对这些内容进行疏理和总结，为自己和有同样困惑的同学答疑解惑。要理解这些复杂的声明和定义，我觉得首先不能着急，应该由浅而深，逐步突破。下面先看一些简单的定义：

        1. 定义一个整型数

            int a;

        2. 定义一个指向整型数的指针

            int *p;

        3. 定义一个指向指针的指针，它指向的指针指向一个整型数

            int **pp;

        到这一步我想大多数人都还好理解，我们可以用一些简单的代码把这三条给串起来：

int a;
int *p;
int **pp;

p = &a;   // p指向整数a所在的地址
pp = &p;  // pp指向指针p

        4. 定义一个包含10个整型数的数组

            int arr[10];

        5. 定义一个指向包含10个整型数数组的指针

            int (*pArr) [10];

        用几行代码将4、5两个定义串起来：

int arr[10];
int (*pArr) [10];

pArr = &arr;

         6. 定义一个指向函数的指针，被指向的函数有一个整型参数并返回整型值

             int (*pfunc) (int);

         7. 定义一个包含10个指针的数组，其中包含的指针指向函数，这些函数有一个整型参数并返回整型值

             int (*arr[10]) (int);

        用几行代码将6、7两个定义串起来：

int (*pfunc) (int);
int (*arr[10]) (int);

arr[0] = pfunc;

        到这一步，似乎就不是那么好理解了。现在需要请出用于理解复杂定义的“右左法则”：

        从变量名看起，先往右，再往左，碰到圆括号就调转阅读的方向；括号内分析完就跳出括号，还是先右后左的顺序。如此循环，直到分析完整个定义。

        让我们用这个方法来分析上面的第6条定义：int (*pfunc) (int);

        找到变量名pfunc，先往右是圆括号，调转方向，左边是一个*号，这说明pfunc是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明(*pfunc)是一个函数，所以pfunc是一个指向这类函数的指针，即函数指针，这类函数具有一个int类型的参数，返回值类型是int。

        接着分析第7条定义：int (*arr[10]) (int);

        找到变量名arr，先往右是[]运算符，说明arr是一个数组；再往左是一个*号，说明arr数组的元素是指针（注意：这里的*修饰的不是arr，而是arr[10]。原因是[]运算符的优先级比*要高，arr先与[]结合。）；跳出圆括号，先往右又遇到圆括号，说明arr数组的元素是指向函数的指针，它指向的函数有一个int类型的参数，返回值类型是int。

        分析完这两个定义，相信多数人心里面应该有点谱了。可应该还有人会问：怎么判断定义的是函数指针（定义6），还是数组指针（定义5），或是数组（定义7）？可以抽象出几个模式：

• type (*var)(...); // 变量名var与*结合，被圆括号括起来，右边是参数列表。表明这是函数指针
• type (*var)[];    //变量名var与*结合，被圆括号括起来，右边是[]运算符。表示这是数组指针
• type (*var[])...;     // 变量名var先与[]结合，说明这是一个数组（至于数组包含的是什么，由旁边的修饰决定）   

        至此，我们应该有能力分析文章开始列出来了几条声明和定义：

        (1)  void * (* (*fp1) (int)) [10];

        找到变量名fp1，往右看是圆括号，调转方向往左看到*号，说明fp1是一个指针；跳出内层圆括号，往右看是参数列表，说明fp1是一个函数指针，接着往 左看是*号，说明指向的函数返回值是指针；再跳出外层圆括号，往右看是[]运算符，说明函数返回的是一个数组指针，往左看是void *，说明数组包含的类型是void *。简言之，fp1是一个指向函数的指针，该函数接受一个整型参数并返回一个指向含有10个void指针数组的指针。

        (2) float (* (*fp2) (int, int, float)) (int);

        找到变量名fp2，往右看是圆括号，调转方向往左看到*号，说明fp2是一个指针；跳出内层圆括号，往右看是参数列表，说明fp2是一个函数指针，接着往 左看是*号，说明指向的函数返回值是指针；再跳出外层圆括号，往右看还是参数列表，说明返回的指针是一个函数指针，该函数有一个int类型的参数，返回值 类型是float。简言之，fp2是一个指向函数的指针，该函数接受三个参数(int, int和float)，且返回一个指向函数的指针，该函数接受一个整型参数并返回一个float。

        (3)  typedef double (* (* (*fp3) ()) [10]) ();

               fp3 a;

        如果创建许多复杂的定义，可以使用typedef。这一条显示typedef是如何缩短复杂的定义的。

        跟前面一样，先找到变量名fp3（这里fp3其实是新类型名），往右看是圆括号，调转方向往左是*，说明fp3是一个指针；跳出圆括号，往右看是空参数列 表，说明fp3是一个函数指针，接着往左是*号，说明该函数的返回值是一个指针；跳出第二层圆括号，往右是[]运算符，说明函数的返回值是一个数组指针， 接着往左是*号，说明数组中包含的是指针；跳出第三层圆括号，往右是参数列表，说明数组中包含的是函数指针，这些函数没有参数，返回值类型是 double。简言之，fp3是一个指向函数的指针，该函数无参数，且返回一个含有10个指向函数指针的数组的指针，这些函数不接受参数且返回double值。

        这二行接着说明：a是fp3类型中的一个。

        (4)  int (* (*fp4()) [10]) ();

        这里fp4不是变量定义，而是一个函数声明。

        找到变量名fp4，往右是一个无参参数列表，说明fp4是一个函数，接着往左是*号，说明函数返回值是一个指针；跳出里层圆括号，往右是[]运算符，说明 fp4的函数返回值是一个指向数组的指针，往左是*号，说明数组中包含的元素是指针；跳出外层圆括号，往右是一个无参参数列表，说明数组中包含的元素是函 数指针，这些函数没有参数，返回值的类型是int。简言之，fp4是一个返回指针的函数，该指针指向含有10个函数指针的数组，这些函数不接受参数且返回 整型值。

• 用typedef简化复杂的声明和定义
  

        以上我们已经看到了不少复杂的声明和定义，这里再举一个例子：

        int *(*a[10]) (int, char*);

        用前面的“右左法则”，我们可以很快弄清楚：a是一个包含10个函数指针的数组，这些函数的参数列表是(int, char*)，返回值类型是int*。理解已经不成问题，这里的关键是如果要定义相同类型的变量b，都得重复书写：

        int *(*b[10]) (int, char*);

        这里有没有方便的办法避免这样没有价值的重复？答案就是用typedef来简化复杂的声明和定义。

        typedef可以给现有的类型起个别名。这里用typedef给以上a、b的类型起个别名：       

typedef int *(*A[10]) (int, char*); // 在之前定义的前面加入typedef，然后将变量名a替换成类型名A

        现在要再定义相同类型的变量c，只需要：

        A c;

        再看一例：

        void (*b[10]) (void (*)());

        先替换右边括号里面的参数，将void (*)()的类型起个别名pParam：       

typedef void (*pParam) ();

        再替换左边的变量b，为b的类型起个别名B：

typedef void (*B) (pParam);

        原声明的简化版：

[cpp] view plain copy