C/C++ typedef用法详解

感谢博主分享，在这篇文章的进行自我学习的整理，后续继续补充，谢谢，学到并将好知识分享，原博主地址：https://blog.youkuaiyun.com/Andrewniu/article/details/80566324

---

一、typedef注意事项？

1、不是简单的字符串替换

typedef 不是简单的宏替换。

typedef char* PSTR
int mystrcmp(const PSTR, const PSTR)
//const PSTR 实际上相当于char* const ，而不是 const char*。
//原因是const给予了整个指针本身的以常量性，也就是形成了常量指针 char* const、

2、存储类的关键字

typedef 在语法上是一个存储类的关键字（如auto、extern、mutable、static、register等一样）

typedef static int INT2; //不可行
//编译将失败，会提示“指定了一个以上的存储类”。
//原因是const给予了整个指针本身的以常量性，也就是形成了常量指针 char* const、

typedef 行为有点像 #define 宏，用其实际类型替代同义字。不同点是 typedef 在编译时被解释，因此让编译器来应付超越预处理器能力的文本替换。例如：
typedef int (*PF) (const char *, const char *);
这个声明引入了 PF 类型作为函数指针的同义字，该函数有两个 const char * 类型的参数以及一个 int 类型的返回值。如果要使用下列形式的函数声明，那么上述这个 typedef 是不可或缺的：
PF Register(PF pf);
Register() 的参数是一个 PF 类型的回调函数，返回某个函数的地址，其署名与先前注册的名字相同。做一次深呼吸。下面我展示一下如果不用 typedef，我们是如何实现这个声明的：
int (*Register (int (*pf)(const char *, const char *))) (const char *, const char *);
很少有程序员理解它是什么意思，更不用说这种费解的代码所带来的出错风险了。显然，这里使用 typedef 不是一种特权，而是一种必需。持怀疑态度的人可能会问：“OK，有人还会写这样的代码吗？”，快速浏览一下揭示 signal()函数的头文件 ，一个有同样接口的函数。
typedef 和存储类关键字（storage class specifier）
这种说法是不 是有点令人惊讶，typedef 就像 auto，extern，mutable，static，和 register 一样，是一个存储类关键字。这并是说 typedef 会真正影响对象的存储特性；它只是说在语句构成上，typedef 声明看起来象 static，extern 等类型的变量声明。下面将带到第二个陷阱：
typedef register int FAST_COUNTER; // 错误
编译通不过。问题出在你不能在声明中有多个存储类关键字。因为符号 typedef 已经占据了存储类关键字的位置，在 typedef 声明中不能用 register（或任何其它存储类关键字）。

3、typedef 和# define 区别

1.typedef 比#define 要好，特别是有指针的场合。

typedef char * pStr1;
#define pStr2 char *;
pStr1 s1,s2;
pStr2 s3,s4;
//上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char，不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字

2.const pStr p2和const long x本质上没有区别。

typedef char * pStr;  
char string[4] = "abc";  
const char *p1 = string;  
const pStr p2 = string;  
p1++;  
p2++;
//p2++出错。这个问题再一次提醒我们：typedef和#define不同，它不是简单的文本替换。上述代码中const pStr p2并不等于const char * p2。const pStr p2和const long x本质上没有区别，都是对变量进行只读限制，只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已。因此，const pStr p2的含义是：限定数据类型为char *的变量p2为只读，因此p2++错误。

typedef & #define的问题
　　> #define用法例子：
　　> #define f(x) xx
　　> main( )
　> 　{
　> 　int a=6，b=2，c；
　　> c=f(a) / f(b)；
　　> printf("%d //n "，c)；
　> 　}
　> 　以下程序的输出结果是: 36。
　> 　因为如此原因，在许多C语言编程规范中提到使用#define定义时，如果定义中包含表达式，必须使用括号，则上述定义应该如下定义才对：
　> 　#define f(x) (xx)
　　> 当然，如果你使用typedef就没有这样的问题。

3.#define与typedef引申谈。

1. #define宏定义有一个特别的长处：可以使用 #ifdef ,#ifndef等来进行逻辑判断，还可以使用#undef来取消定义。
2. typedef也有一个特别的长处：它符合范围规则，使用typedef定义的变量类型其作用范围限制在所定义的函数或者文件内（取决于此变量定义的位置），而宏定义则没有这种特性。

二、typedef四个用途？

1、消除重复定义和隐藏指针

重复定义有 81 个字符元素的数组：
char line[81];char text[81];
定义一个 typedef，每当要用到相同类型和大小的数组时，可以这样：
typedef char Line[81]; Line text, secondline;getline(text);
同样，可以象下面这样隐藏指针语法：
typedef char * pstr;
int mystrcmp(pstr, pstr);
这里将带我们到达第一个 typedef 陷阱。标准函数 strcmp()有两个‘const char *’类型的参数。因此，它可能会误导人们象下面这样声明 mystrcmp()：
int mystrcmp(const pstr, const pstr);
这是错误的，按照顺序，‘const pstr’被解释为‘char * const’（一个指向 char 的常量指针），而不是‘const char *’（指向常量 char 的指针）。这个问题很容易解决：
typedef const char * cpstr; int mystrcmp(cpstr, cpstr); // 现在是正确的
记住： 不管什么时候，只要为指针声明 typedef，那么都要在最终的 typedef 名称中加一个 const，以使得该指针本身是常量，而不是对象。

2、同时声明指针型的多个对象

定义一种类型的别名，不是简单的替换，可以同时声明指针型的多个对象。
eg：

//这样只声明了一个指向字符变量的指针和一个字符变量。
//char* pa,pb;
//使用typedef同时声明了两个指向字符变量的指针
typedef char* PCHAR;
PCHAR pa,pb;

3、简化struct声明新对象

//struct 声明形式：struct 结构名 对象名
struct tagPOINT1
{
	int x;
	int y;
};
struct tagPOINT1 p1;

//在C++中可以直接写：结构名 对象名 eg：tapPOINT1 p1;
//在以前的程序中，经常看见很多人这么写，就是为了简化声明结构方式。
typedef struct tagPOINT
{
	int x;
	int y;
}POINT;
POINT p1;

typedef与结构结合使用
typedef struct tagMyStruct {
int iNum;
long lLength; 　} MyStruct;
这语句实际上完成两个操作： 1) 定义一个新的结构类型
struct tagMyStruct {
int iNum;
long lLength; };
分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。
我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。
2) typedef为这个新的结构起了一个名字，叫MyStruct。
　　> typedef struct tagMyStruct MyStruct;
　　> 因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。
3)、规范做法：
　> 　struct tagNode
　> 　{
　> 　char *pItem;
　> 　struct tagNode *pNext;
　> 　};
　> 　*typedef struct tagNode pNode;

4、定义与平台无关的类型。

//跨平台，只需改变typedef本身就行，不用对其源代码做任何修改。
//平台1
typedef long double REAL;
//平台2
typedef float REAL;

5、为复杂的声明定义一个新的简单的别名。

理解复杂声明遵循一个法则：右左法则
1.从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读方向；
2.括号内分析完就跳出括号，还是按先往右，再往左顺序阅读。
3.如此循环，直至分析声明结束

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

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

//方法是：在原来的声明里逐步用别名替换一部分复杂声明，如此循环，把带变量名的部分留到最后替换，得到的就是原声明的最简化版
//eg1:原声明：int *(*a[5])(int, char*);
//变量名为a，直接用新别名pFun替换a。
typedef int*(*pFun)(int,char*)
//原声明的最简化版：
pFun a[5]

//eg2:原声明：void (*b[10])(void(*)());  变量名为b 先替换右边括号的，pFunParam 为别名一：
typedef void (*pFunParam)()  //在替换左边的变量b，pFunx为别名二：
typedef void (*pFunx)(pFunParam)
//原声明的最简化版：
pFunx b[10]

//eg3:原声明：double(*)()(*e)[9]);  变量名为e 先替换左边部分，pFuny 为别名一：
typedef double (*pFuny)()  //在替换变量右边的，pFunParamy为别名二：
typedef pFuny (*pFunParam)[9]
//原声明的最简化版：
pFunParam e