typedef 取别名 linuxc

//2022年1月23日
#include <stdio.h>
#define NUM  5

typedef int INT;				//给整型int定义别名叫INT
typedef int * INTP;				//给整型指针 int*定义一个别名叫INTP
typedef int ARR[NUM];			//定义一个数组类型int [NUM]的别名叫作ARR
typedef int *PARR[NUM];			//定义一个指针数组类型 int *[NUM]别名叫作PARR
typedef int (*ARRP)[NUM];		//定义一个定义一个数组指针类型int (*)[NUM]别名叫作ARRP

//int (*PFUNC)(int ,int);
//PFUNC指向一个函数，该函数接受两个int类型的参数，并返回一个int								
typedef int (*PFUNC)(int ,int);	//定义一个指针，该指针指向该函数，该函数接受两个int型参数，返回一个int
//int (*PFUNCARR[NUM])(int ,int)
//PFUNCARR指向一个指针的数组，该数组中的指针指向一个函数，该函数接受两个int类型的参数并返回一个int
typedef int (*PFUNCARR[NUM])(int ,int);	//定义一个有NUM个元素的数组, 每个元素为 int (*)(int, int)的函数指针的类型int (*[5])(int, int)的别名叫做PFARR
// 指向 函数指针数组  数组指针
//int (*((*PFUNCPARR)[NUM]))(int,int)
//PFUNCPARR指向一个数组的指针，该指针指向一个函数，该函数接受两个int类型的参数并返回一个int
typedef int (*((*PFUNCPARR)[NUM]))(int,int);	//定义一个有NUM给元素的数组，每个元素为
												//int(*)(int,int)的函数指指针类型int(*[NUM])(int,int)的别名叫做PFUNCPARR


int f1(int m,int n);
int f2(int m,int n);
int f3(int m,int n);
int f4(int m,int n);
int f5(int m,int n);

int main(void)
{

//gcc type_type.c -DI
#ifdef I
	INT n=10;
	//int n;
	
	printf("INT n = %d\n",n);
#endif
//gcc type_type.c -DPI
#ifdef PI
	int n=10;
	INTP s;
	//int *n;
	s=&n;
	printf("*s = %d\n",*s);/
#endif

//gcc type_type.c -DAR
#ifdef AR
	ARR n={1,2};
	//int n[NUM];
	n[2]=3;
	n[3]=4;
	n[4]=5;
	
	for(int i=0;i<NUM;i++)
		printf("n[%d] = %d\n",i,n[i]);
#endif

//gcc type_type.c -DPAR
#ifdef PAR
	int i=1,j=2,k=3;
	PARR n = {&i,&j,&k,0,NULL};
	//int *n[NUM];
	
	for(int i=0;i<NUM;i++)
		printf("*n[%d] = %d\n",i,*n[i]);
#endif	


//gcc type_type.c -DARP
#ifdef ARP
	int tmp[NUM] = {1,2,3,4,5};
	ARRP n;
	//int (*n)[5];
	n = &tmp;	//&tmp ==	&&tmp[0]

	for (int i = 0; i < NUM; i++)
	{
		printf("(*n)[%d] = %d\n",i,*(*(n)+i));
	}


#endif

//gcc type_type.c -DPF
#ifdef	PF
	PFUNC pf;
	//int (*pf)(int int);
	pf = &f1;
	int res = (*pf)(1,2);
	printf("%d\n",res);

#endif

//gcc type_type.c -DPFARR	
#ifdef	PFARR
	PFUNCARR pfa = {&f1,NULL,NULL,NULL,NULL};
	//int (*pfa[NUM])(int,int);
	
	pfa[1] = &f2;
	pfa[2] = &f3;
	pfa[3] = &f4;
	pfa[4] = &f5;

	for(int i=0;i<NUM;i++)
	{	
		int j = pfa[i](1+i,4+i);
		printf("f%d = %d\n",i,j);
	}
#endif

//gcc type_type.c -DPFPARR
#ifdef PFPARR
	PFUNCARR pfa ={&f1,&f2,&f3,&f4,&f5};
	//int (*pfa[NUM])(int,int);

	PFUNCPARR pfpa=&pfa;  //pfa == &pfa[0];
	//int (*((*pfpa)[NUM]))(int,int);
	(*(*pfpa+0))(1,2);

#endif
// #ifdef
// #endif
	int tmp[NUM]={1,2,3,4,5};
	int (*p)[NUM];
	int *pt[NUM];
	for(int i=0;i<NUM;i++)
	{
		pt[i]=&tmp[i];
		printf("%d",*(*pt+i));
		printf(" %d ",*pt[i]);
	}
	//1 	2 	3 	4 	5
	p = &tmp;	//&tmp == &&tmp[0]
	printf("%d\n",*(*p+1));//2
}



int f1(int m,int n)
{
	printf("%d %d\n",m,n);
	return 1;
}
int f2(int m,int n)
{
	printf("%d %d\n",m,n);
	return 2;
}
int f3(int m,int n)
{
	printf("%d %d\n",m,n);
	return 3;
}
int f4(int m,int n)
{
	printf("%d %d\n",m,n);
	return 4;
}

int f5(int m,int n)
{
	printf("%d %d\n",m,n);
	return 5;
}





// int a;				一个整型数
// int *a;				一个指向整型数的指针
// int *(*a);			一个指向指针的指针，它的指向的指针是指向一个整型数
// int a[10];			一个有10个整型数的数组
// int *a[10];			一个有10个指针的数组，该指针指向一个整型数
// int (*a)[10];		一个指向有10个整型数的数组的指针
// int (*a)(int)		一个指向函数的指针，该函数有一个整型参数并返回一个整型数
// int	(*a[10])(int)	一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数