有时候为了代码的可移植和跨平台的开发,或者是为了缩短书写字符,会使用 typedef 进行类型重命名。
typedef
作用
用自定义名称为已有数据类型命名。
定义为:
typedef datatype name;
使用方法
为了便于记忆,可以归纳为步骤:
-
先用已有类型定义一个变量
-
在定义语句类型前加 typedef
-
将变量名换成自定义名称
-
最后一定有分号;
看下边的程序:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int TYPE32;
typedef int ARRAY[10];
typedef char *POINTER;
typedef char *POINTERARRAY[3];
int main()
{
TYPE32 a = 10;
ARRAY arr = {1,2,3,4,5,6,7,8,9,10};
POINTER ps= "123";
POINTERARRAY pt= {"123","456","789"};
printf("sizeof(TYPE32) = %d\n",sizeof(TYPE32));
printf("sizeof(ARRAY) = %d\n",sizeof(ARRAY));
printf("sizeof(POINTER) = %d\n",sizeof(POINTER));
printf("sizeof(POINTERARRAY) = %d\n",sizeof(POINTERARRAY));
putchar(10);
printf("a = %d\n",a);
putchar(10);
for (int i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
printf("arr[%d] = %d\n",i,arr[i]);
putchar(10);
printf("a = %s\n",ps);
putchar(10);
for (int i = 0;i<sizeof(pt)/sizeof(pt[0]);i++)
printf("arr[%d] = %s\n",i,pt[i]);
return 0;
}
结果为:
sizeof(TYPE32) = 4
sizeof(ARRAY) = 40
sizeof(POINTER) = 4
sizeof(POINTERARRAY) = 12
a = 10
arr[0] = 1
arr[1] = 2
arr[2] = 3
arr[3] = 4
arr[4] = 5
arr[5] = 6
arr[6] = 7
arr[7] = 8
arr[8] = 9
arr[9] = 10
a = 123
arr[0] = 123
arr[1] = 456
arr[2] = 789
主要是关于数组的 typedef。不要搞混淆了。
#define
作用
#define 只是在预处理阶段进行文本替换,使用格式为:
#define 源文本 替换文本
有时候 typedef 和 #define 的作用会一样,但有时却有很大差别。看下边的程序:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef char *POINTER;
#define POINTERD char *
int main()
{
POINTER pa,pb;
printf("sizeof(POINTER) = %d\n",sizeof(POINTER));
printf("sizeof(pa) = %d sizeof(pb) = %d\n",
sizeof(pa),sizeof(pb));
POINTERD pc,pd;
printf("sizeof(POINTERD) = %d\n",sizeof(POINTERD));
printf("sizeof(pc) = %d sizeof(pd) = %d\n",
sizeof(pc),sizeof(pd));
return 0;
}
结果为:
sizeof(POINTER) = 4
sizeof(pa) = 4 sizeof(pb) = 4
sizeof(POINTERD) = 4
sizeof(pc) = 4 sizeof(pd) = 1
从上边的结果可以看出:
- typedef 是一个语句,句尾有分号
- #define 是一个宏,并不是完整的语句
- typedef 只能给已经存在的类型起别名,不能无中生有构造新类型
- 宏 define 是在预处理的时候完成的,typedef 则是在编译时完成的,相比下 typedef 更好用
- 一般情况下,重新命名的类型习惯用大写表示,以示区分
- 有时我们会将某些结构简单的函数进行宏定义,进行代码嵌套,从而减少代码冗余,减少调用开销,但也会造成编译文件过大