再次回顾typedef

之前转载了两篇文章非常详细，今天再来回顾下
重点1.

陷阱一：

记住，typedef是定义了一种类型的新别名，不同于宏，它不是简单的字符串替换。比如： 先定义： typedef char* PSTR;
然后： int mystrcmp(const PSTR, const PSTR);

const PSTR实际上相当于const char吗？不是的，它实际上相当于char const。
原因在于const给予了整个指针本身以常量性，也就是形成了常量指针char const。*
简单来说，记住当const和typedef一起出现时，typedef不会是简单的字符串替换就行。

陷阱二：

typedef在语法上是一个存储类的关键字（如auto、extern、mutable、static、register等一样），虽然它并不真正影响对象的存储特性，如：
typedef static int INT2; //不可行 编译将失败，会提示“指定了一个以上的存储类”。

第一个陷阱是编译时，发现顶层const和底层const并不能如直接替换那样分析。

	char str[10] = "abcdef";
	const char* p1 = str;其中p1是可变指针指向不可变的字符串。所以p1++正确。
	const pchar p2 = str;定义了一种新类型，所以 const pchar p2; p2是const类型的，所以p2++出错。
	p1++;
	p2++;
	return 0;

再一个typedef用来实现复杂的函数指针的定义，主要是为了简单明了，减少错误。

重点2 ：另一个就是解析方法，也就是怎么读typedef定义：

理解复杂声明可用的“右左法则”：

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

int (*func)(int p); 首
先找到变量名func，外面有一对圆括号，而且左边是一个号，这说明func是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明
(func)是一个函数，所以func是一个指向这类函数的指针，即函数指针，这类函数具有int类型的形参，返回值类型是int。

int (func[5])(int ); func
右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个，说明func的元素是指针（注意这里的不是修饰func，而是修饰
func[5]的，原因是[]运算符优先级比高，func先跟[]结合）。跳出这个括号，看右边，又遇到圆括号，说明func数组的元素是函数类型的指
针，它指向的函数具有int类型的形参，返回值类型为int。

也可以记住2个模式：

type (*)(....)函数指针  

type (*)[]数组指针

用一个完整实例来体现

#include <iostream>
#include <cstring>
using namespace std;
int calc(int a, int b, char op);
typedef int(*FP_CALC)(int, int);// 定义指向这类函数的指针 
//int(*s_calc_func(char op)) (int, int);
FP_CALC calc_func(char op);
int add(int, int);
int sub(int, int);
int mul(int, int);
int div1(int, int);

int main()
{
	int a = 100, b = 20;
	printf("calc(%d, %d, %c) = %d\n", a, b, '+', calc(a, b, '+'));
	printf("calc(%d, %d, %c) = %d\n", a, b, '-', calc(a, b, '-'));
	printf("calc(%d, %d, %c) = %d\n", a, b, '*', calc(a, b, '*'));
	printf("calc(%d, %d, %c) = %d\n", a, b, '/', calc(a, b, '/'));
	system("pause");

int calc(int a, int b, char op)
{
	FP_CALC fp = calc_func(op); // 下面是类似的直接定义指向函数指针变量 
								// 下面这行是不用typedef，来实现指向函数的指针的例子，麻烦！ 
	//int(*s_fp)(int, int) = s_calc_func(op);
	// ASSERT(fp == s_fp); // 可以断言这俩是相等的
	if (fp) return fp(a, b);
	else return -1;
}
//int(*s_calc_func(char op)) (int, int)  //(这个就是不用typedef实现）
//{
//	return calc_func(op);
//}
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div1(int a, int b)
{
	return b ? a / b : -1;
}
FP_CALC calc_func(char op)
{
	switch (op)
	{
	case '+': return add;
	case '-': return sub;
	case '*': return mul;
	case '/': return div1;
	default:
		return NULL;
	}
	return NULL;
}

调用calc，调用calc_func返回指向不同运算方法的函数指针fp，完成加减乘除

来看一下，如果不用typedef呢？

int (*s_calc_func(char op))(int , int );

按照右左法则来分析，从s_calc_func这个名字开始，向右碰到括号，说明其是一个函数，参数为char型，向左有*，说明其是一个参数为char，返回值为指针的函数，再向右发现又碰到了一个括号，说明这是一个参数为char，返回值为指针的函数，返回的指针所指向的也是一个函数，这个函数的形参为两个int型，且返回值为int型。（够绕吧）

所以即便聪明的程序员也不能立马看懂它的意思，因此用typedef简化是很有必要的：

typedef int(*FP_CALC)(int, int);// 定义指向这类函数的指针 
FP_CALC calc_func(char op);

同样是右左法则，从FP_CALC开始，首先在第一个括号一其是一个指针，跳出括号，向右又碰见括号，说明FP_CALC这个指针指向一个函数，形参为两个int型，返回值也为int型。总结：FP_CALC定义了一种指向形参为两个int，返回值为int的函数的指针。
然后下面一句就是再定义一个函数，这个函数的形参为char类，返回值为FP_CALC类。
和不用typedef时的分析一对比，发现就是把上面的定义分了两步走，有心的读者可以尝试多理解下。

所以有等价关系：

FP_CALC fp = calc_func(op); 							 
int(*s_fp)(int, int) = s_calc_func(op);
ASSERT(fp == s_fp); // 可以断言这俩是相等的