C语言中的别名

定义别名

当我们用struct,union定义变量时，关键字struct,union不可省略，这使得代码看起来臃肿，当用一个复杂指针多次定义变量时，不仅显得臃肿，还容易写错，这就背离了C语言简洁高效的风格。此时为数据类型定义别名是一种有效的解决方案，早些时候C语言可以通过宏来定义别名，例如：
#define int Integer
Integer a=1;
这种方式有很大的局限性，它只能用于一行，可以用来定义基本数据类型的常量，但不能用于结构体，例如：
#define struct Student{int num;char name[20];}; Student
如果再用Student s1定义变量就会报错，因为#define的本质是文本替换，C语言不允许同样的struct Student被定义两次，我们应该选择更加标准的方式，那就是使用typedef关键字，typedef不是宏，而是定义别名的关键字，为结构体定义别名的代码如下：
typedef struct Student
{
int num;
char name[20];
} Student;

int main(int argc, char* argv[])
{
Student s1;
}
上面代码为struct Student类型定义别名Student，这种方式与#define有着本质的区别：typedef参与编译，Student被看作一个真正的数据类型，而#define是预编译宏。Student和struct Student是同一种数据类型，只是名称不同，有的书籍将typedef定义的类型看作一个新的数据类型，但本质上还是别名，因为我们并未创建新的数据类型。typedef常用于定义结构体、联合体的别名，即使结构体或联合体有名称，定义别名后不用再写烦人的struct和union关键字了。

除了结构体和联合体，typedef实际上可以为任何类型定义别名，甚至是匿名类型。例如：

typedef struct
{
	int num;
	char name[20];
} Student;
如果不定义结构体的匿名，下次使用匿名结构体类型声明变量时只能再次将结构体定义写上去，例如：
typedef struct
{
	int num;
	char name[20];
} s1,s2;

讲到这里，大部分人会认为别名仅用于简化代码，那就太小看它了，typedef不仅仅用于简化代码，它还能表达编译器不能直接写出的类型，例如数组类型和函数类型，下面会分别讲解。

为基本数据类型定义别名

#define和typedef都可以为基本数据类型定义别名，目的主要用于代码移植，当不确定int是2位还是4位时，我们可以将整数定义为Integer以便今后改写，例如：
typedef short Integer; //2位
typedef int Integer;//4位
C99新增的size_t和time_t就是为兼容不同编译器定义的别名，size_t可以为unsigned int, unsigned long, unsigned long long，time_t可以是unsigned long, unsigned long long。

为数组类型定义别名

当我们定义一个函数test()时，如下：
int test(int x,int y)
{
return x+y;
}
test是函数名，函数类型为int ()(int,int)，是一个指针类型，函数名为函数定义的入口地址，但是int ()(int,int)类型不被编译器认可，我们只能为它定义一个别名，例如：

#include <stdio.h>
typedef int (*Myfun)(int,int);

int test(int x,int y)
{
	return x+y;
}

Myfun p= test;

int main(void)
{
	printf("%d\n",test);
	printf("%d\n",p);
	p(1,2);
}

函数类型的别名特别有用，由于函数类型不能直接书写，当需要使用强制类型转换明确写出函数类型时就没有办法，例如从动态库中加载了一个函数，由于不知道加载的函数类型，GetProcAddress()返回一个通用函数指针，必须将它强制转化为具体函数类型才能进行调用，这时别名就显得很有用了。

为函数类型定义别名

当我们定义一个函数test()时，如下：

int test(int x,int y)
{
	return x+y;
}

test是函数名，函数类型为int ()(int,int)，是一个指针类型，函数名为函数定义的入口地址，但是int ()(int,int)类型不被编译器认可，我们只能为它定义一个别名，例如：

#include <stdio.h>
typedef int (*Myfun)(int,int);

int test(int x,int y)
{
	return x+y;
}

Myfun p= test;

int main(void)
{
	printf("%d\n",test);
	printf("%d\n",p);
	p(1,2);
}

函数类型的别名特别有用，由于函数类型不能直接书写，当需要使用强制类型转换明确写出函数类型时就没有办法，例如从动态库中加载了一个函数，由于不知道加载的函数类型，GetProcAddress()返回一个通用函数指针，必须将它强制转化为具体函数类型才能进行调用，这时别名就显得很有用了。

定义指针的别名

指针类型看起来都很复杂，特别是组合指针格式更为复杂，如果为此定义别名，代码会简洁很多，例如将字符串指针类型定义为String：
typedef char* String;
用String s1,s2看起来会更符合高级语言的习惯。对于二维数组来说，如果用Row来表示二维数组的行，Col表示二维数组的列，代码看起来更加简明：

#include<stdio.h>
typedef int (*Row)[2];
typedef int *Col;

int a[3][2]={{1,1},{2,2},{3,3}};

int main(void)
{
	Row p=a; //行地址
	Col q; //列地址
	do
	{
		q=*p;
		do printf("%d\n",*q);while(++q<*p+2);
	}while(++p<a+3);
}

为指针数组定义别名

如果为char *p[]定义别名StringArr，今后就可以用StringArr定义包含n个字符串的数组，例如：

#include<stdio.h>
typedef char* StringArr[];

int main(void)
{
	StringArr strarr = { "aa","bb","cc" };
	return 0;
}
由于char *p[]结合了数组类型，因此不能直接书写该类型，通过定义别名既能书写该类型又便于理解。类似的我们也可以为函数数组定义别名，例如：
#include <stdio.h>
typedef void (*FunArr[10])(int arg);

int test1(int arg)
{
	printf("%d ", arg);
}

int test2(int arg)
{
	printf("%d ", arg);
}

int main(void)
{
	FunArr funArr = {test1,test2};
	for (int i = 0; i < 10; i++) if (funArr[i]) funArr[i](i);
}

同时定义多个别名

C允许同时为类型定义多个别名，它们之间用逗号隔开，例如：
typedef char MYCHAR,MY_CHAR;
定义多个别名看起来没什么用，但是可以同时定义一个类型的别名和它的指针别名，例如：

#include<stdio.h>

typedef char MYCHAR,*MY_CHAR;

int main()
{
	MYCHAR c = 'a';
	MY_CHAR mychar = &c;
	putchar(c);
	putchar(*mychar);
}

这种形式用于定义匿名结构体更为简洁，例如：

typedef struct 
{   
    char* lpTitle;    
    int dwX;    
    int dwY;    
} STARTUPINFO, *LPSTARTUPINFO;

为指针的指针定义别名

如果需要一个变量指向指针数组，就必须定义指针的指针，此时将StringP定义为****char意思更加明确：

#include<stdio.h>
typedef char\* StringArr3[3];
typedef char** StringP;

int main(void)
{
	StringArr3 str = {"aa","bb","cc"};
	StringP p=str;
	p++;
	puts(*p);
	return 0;
}

头文件中的别名

别名看起来不起眼，但在C语言中却特别重要，它不仅解决了无法书写类型的问题，还使得代码焕然一新，查看导入的标准库中的头文件，会发现别名无处不在，虽然别名可以精简代码，但过多的别名同时也增加了阅读代码的难度，特别是为同一种类型定义了多个别名，很容易让人迷惑。

我们知道宏命令如#define只对使用该宏的文件中起作用，因为它在预编译时被替换掉，不会影响其它的文件。再来看看别名，由于typedef参与编译，因此别名是包含在项目中的，但只有执行了typedef语句后才会生成别名，而且别名不能进行预定义声明，只允许反复定义，这就使得别名实际上还是有作用域的，C标准规定别名的作用域是typedef定义的位置，例如：

#include <stdio.h>
typedef void (*FunArr[10])(int arg);

int test1(int arg)
{
	typedef int FunArr;
	FunArr m = 1;
	printf("%d ", m);
}

int test2(int arg)
{
	typedef float FunArr;
	FunArr n = 2.0;
	printf("%f ", n);
}

int main(void)
{
	FunArr funArr = {test1,test2};
	for (int i = 0; i < 10; i++) if (funArr[i]) funArr[i](i);
}

上面代码在函数内部和外部都定义了同名的别名，但是类型不一样，由于作用域不一样，它们互不影响。要在多个文件中使用一种类型，只有在每个文件中反复定义该类型的别名，这显然很麻烦，一个解决方法是在头文件中定义别名，需要别名时导入头文件即可，即使在不同的头文件中多次定义相同类型别名也不会报错，编译器会自动忽略重复的语句，但不能将不同的类型定义为相同的别名，这会导致编译器报重复定义的错误，因此我们自己定义的别名不能和标准库中的别名相同。宏也可以反复定义，但当同名宏被反复定义时后面的宏会覆盖前面的宏，而我们可能一无所知，这个问题更加严重，这时需要使用#ifdef这样的预编译命令先测试宏是否已定义，但预编译不是这里要讨论的内容。