typedef的真正含意
1.
找到你所要申明的通用格式。例如这里申明
int a[4], b[4], c[4];
只有
a,b,c
不同,它们有相同的申明模式
int <
名字
>[4];
2. 用你想申明的新类型名代替通用格式中的变化部分。例如这里就是用新类型 int_array 代替 a,b,c 所在的位置,再在前面加上 typedef 符号,即:
typedef int int_array[4];
3. 以后你想申明处在上面 int_array 位置的 a,b,c 类型时,就可以用如下语句:
int_array a, b, c;
2. 用你想申明的新类型名代替通用格式中的变化部分。例如这里就是用新类型 int_array 代替 a,b,c 所在的位置,再在前面加上 typedef 符号,即:
typedef int int_array[4];
3. 以后你想申明处在上面 int_array 位置的 a,b,c 类型时,就可以用如下语句:
int_array a, b, c;
简单点说在一个定义
typedef <
字符串
>
;中,
<
字符串
>
中会出现一个未定义的类型名
Type_A,
当你使用该
typedef
的时候:
Type_A object; 它的含义就是:你实际上申明的是用 object 名去替换 < 字符串 > 中的 Type_A 。
例如 typedef int int_array[4];
int_array object;
实际上你写的申明是:用 object 替换 字符串 " int int_array[4];" 中的 int_array 得到的结果: int object[4];
这也就是编译器处理 tyepdef 定义的原理。
Type_A object; 它的含义就是:你实际上申明的是用 object 名去替换 < 字符串 > 中的 Type_A 。
例如 typedef int int_array[4];
int_array object;
实际上你写的申明是:用 object 替换 字符串 " int int_array[4];" 中的 int_array 得到的结果: int object[4];
这也就是编译器处理 tyepdef 定义的原理。
定义类型只用写出一个完整的定义
..
前边上
typedef
就行了
.
char *cstr;// 定义了一个 char* 变量 cstr.
typedef char *cstr;// 为 char* 起个别名 cstr;
int int_array[10];// 定义一个数组 int_array.
typedef int int_array[10]//int_array 变成了 int[10] 的别名 .
void (*pfn)(void);// 定义了一个函数指针 .
typedef void (*pfn)(void);// 为此函数指针起了个别名 .
typedef int (*pf)();
pf test[10];
这样定义就是把 pf 作为一个 “ 新 ” 类型,是一个 int 型的函数指针类型。
所以, pf test[10];// 这样就是定义了函数指针的数组,数组含 10 个元素。
char *cstr;// 定义了一个 char* 变量 cstr.
typedef char *cstr;// 为 char* 起个别名 cstr;
int int_array[10];// 定义一个数组 int_array.
typedef int int_array[10]//int_array 变成了 int[10] 的别名 .
void (*pfn)(void);// 定义了一个函数指针 .
typedef void (*pfn)(void);// 为此函数指针起了个别名 .
typedef int (*pf)();
pf test[10];
这样定义就是把 pf 作为一个 “ 新 ” 类型,是一个 int 型的函数指针类型。
所以, pf test[10];// 这样就是定义了函数指针的数组,数组含 10 个元素。
总结:
typedef
的作用是将一个变量变为它本身的类型,而不是为一个类型定义一个别名。
typedef
使用大全
1(
数组
)
<script type=text/javascript> </script>typedef到处都是,但是能够真正懂得typedef使用的不算太多。对于初学者而言,看别人的源码时对到处充斥的typedef往往不知所错,而参考书又很少,所以在此给出一个源码,供大家参考
#include
<stdio.h>
#include
<iostream.h>
/*
避免
Visual C
的
for
与标准
for
的不同
*/
#define
for
if
(0);
else
for
/* dim(a)
是用于计算
a
的维数,不过只能计算数组的维数,不能计算指针的维数
*/
#define
dim(a) (
sizeof
(a)/
sizeof
(a[0]))
/* N1
到
N4
是几个常量,以枚举的形式定义
*/
enum
{N1 = 2, N2 = 3, N3 = 4, N4 = 5};
/*
这个
C
程序员都知道,就是将
DataType
定义为
int
型,便于扩充
*/
typedef
int
DataType;
/*
定义一个一维数组,数组的元素维整型值
*/
typedef
DataType ARR1[N4];
/*
再定义一个一维数组,数组的元素维
ARR1
型,不过
ARR1
又是一个数组,所以
* ARR2
实际上是一个矩阵
*/
typedef
ARR1 ARR2[N3];
/*
此处完全等价为
typedef int ARR2[N3][N4];*/
/*
按照
ARR2
的解释,
ARR3
也是一个一维数组,不过数组元素的类型是
ARR2
的类型
*
所有
ARR3
是一个三维数组
*/
typedef
ARR2 ARR3[N2];
/*
此处完全等价为
typedef int ARR3[N2][N3][N4];*/
/*
分别用定义好的
ARR1
,
ARR2
,
ARR3
定义三个变量
a, b, c */
ARR1 a;
/*
此处完全等价于:
int a[N4]; */
ARR2 b;
/*
此处完全等价于:
int b[N3][N4]; */
ARR3 c;
/*
此处完全等价于:
int c[N2][N3][N4]; */
/*
下面函数给大家个示例看
a,b,c
如何使用
*/
void
exam_1()
{
for
(
int
i=0; i<dim(a); i++) a[i] = i+1;
for
(
int
i=0; i<dim(b); i++)
for
(
int
j=0; j<dim(b[0]); j++)
b[i][j] = (i+1)*10 + (j+1);
for
(
int
i=0; i<dim(c); i++)
for
(
int
j=0; j<dim(c[0]); j++)
for
(
int
k=0; k<dim(c[0][0]); k++) c[i][j][k] = (i+1)*100 + (j+1)*10 + (k+1);
printf("/nThe a is :/n");
for
(
int
i=0; i<dim(a); i++) printf("%4d ", a[i]);
printf("/n");
printf("/nThe b is :/n");
for
(
int
i=0; i<dim(b); i++)
{
for
(
int
j=0; j<dim(b[0]); j++) printf("%4d ", b[i][j]);
printf("/n");
}
printf("/nthe c is:/n");
for
(
int
i=0; i<dim(c); i++)
{
for
(
int
j=0; j<dim(c[0]); j++)
{
for
(
int
k=0; k<dim(c[0][0]); k++) printf("%4d ", c[i][j][k]);
printf("/n");
}
printf("/n");
}
}
/*
下面函数给大家演示数组在内存中的排列
*/
void
exam_2()
{
int
*pn =
NULL
;
pn = (
int
*)a
; /*
等价于
pn = &a[0]; */
printf("/nThe a is :/n");
for
(
int
i=0; i<
sizeof
(a)/
sizeof
(DataType); i++) printf("%4d ", pn[i]);
printf("/n");
pn = (
int
*)b;
/*
等价于
pn = &b[0][0]; */
printf("/nThe b is :/n");
for
(
int
i=0; i<
sizeof
(b)/
sizeof
(DataType); i++) printf("%4d ", pn[i]);
printf("/n");
pn = (
int
*)c;
/*
等价于
pn = &c[0][0][0]; */
printf("/nThe c is :/n");
for
(
int
i=0; i<
sizeof
(c)/
sizeof
(DataType); i++) printf("%4d ", pn[i]);
printf("/n");
}
int
main(
int
argc,
char
* argv[])
{
exam_1();
exam_2();
return
0;
}
typedef
使用大全
3
(指向函数的指针)
<script type=text/javascript> </script>在typedef的使用中,最麻烦的是指向函数的指针,如果没有下面的函数,你知道下面这个表达式的定义以及如何使用它吗?
int
(*
s_calc_func
(
char
op))(
int
,
int
);
如果不知道,请看下面的程序,里面有比较详细的说明
//
定义四个函数
int
add(
int
,
int
);
int
sub(
int
,
int
);
int
mul(
int
,
int
);
int
div(
int
,
int
);
//
定义指向这类函数的指针
typedef
int
(*FP_CALC)(
int
,
int
);
//
我先不介绍,大家能看懂下一行的内容吗?
int
(*
s_calc_func
(
char
op))(
int
,
int
);
//
下一行的内容与上一行完全相同,
//
定义一个函数
calc_func
,它根据操作字符
op
返回指向相应的计算函数的指针
FP_CALC
calc_func(
char
op);
//
根据
op
返回相应的计算结果值
int
calc(
int
a,
int
b,
char
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
div(
int
a,
int
b)
{
return
b? a/b : -1;
}
//
这个函数的用途与下一个函数作业和调用方式的完全相同,
//
参数为
op
,而不是最后的两个整形
int
(*s_calc_func(
char
op)) (
int
,
int
)
{
return
calc_func(op);
}
FP_CALC
calc_func(
char
op)
{
switch
(op)
{
case
'+':
return
add;
case
'-':
return
sub;
case
'*':
return
mul;
case
'/':
return
div;
default
:
return
NULL
;
}
return
NULL
;
}
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;
}
void
test_fun()
{
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, '/'));
}
运行结果
calc(100, 20, +) = 120
calc(100, 20, -) = 80
calc(100, 20, *) = 2000
calc(100, 20, /) = 5
typedef可以定义各种类型名,但是不能用来定义变量;
typedef只是对已经存在的类型增加一个类型名,没有创造新的类型;
typedef和#define虽然能起到类似的作用,但是两者不同,
#define属于预编译处理,typedef采用定义变量的方法定义一个类型;
当不同的源文件中使用同一类型数据时,常常吧它们单独存放在一个文件中,
然后在需要用到它们的时候,在文件中用#include命令包含进来;
使用typedef有益于程序的通用性和移植。
typedef只是对已经存在的类型增加一个类型名,没有创造新的类型;
typedef和#define虽然能起到类似的作用,但是两者不同,
#define属于预编译处理,typedef采用定义变量的方法定义一个类型;
当不同的源文件中使用同一类型数据时,常常吧它们单独存放在一个文件中,
然后在需要用到它们的时候,在文件中用#include命令包含进来;
使用typedef有益于程序的通用性和移植。
1、用其定义新的类型名代替已有的类型
typedef int INTEGER;
用INTEGER代表int类型
即int i,j;可以用INTEGER i,j;来代替
用INTEGER代表int类型
即int i,j;可以用INTEGER i,j;来代替
2、定义结构体
typedef struct
{
int month;
int day;
int year;
}DATE;
新类型名DATE代表上面的结构体类型。
即DATE birthday;声明一个结构体。
DATE *p;//p为指向此结构体类型数据的指针
{
int month;
int day;
int year;
}DATE;
新类型名DATE代表上面的结构体类型。
即DATE birthday;声明一个结构体。
DATE *p;//p为指向此结构体类型数据的指针
3、其他
⑴
typedef int NUM[100];//定义NUM为整型数组类型
NUM xyz;//定义xyz为整型数组变量
⑵
typedef char *cs;//定义cs为字符串指针类型
cs p,s[10];//p为字符串指针变量,s为指针数组
⑶
typedef int (*ptr)();//定义ptr为指向函数的指针类型,该函数返回整型值
ptr p1,p2;//p1,p2为ptr类型的指针变量
⑴
typedef int NUM[100];//定义NUM为整型数组类型
NUM xyz;//定义xyz为整型数组变量
⑵
typedef char *cs;//定义cs为字符串指针类型
cs p,s[10];//p为字符串指针变量,s为指针数组
⑶
typedef int (*ptr)();//定义ptr为指向函数的指针类型,该函数返回整型值
ptr p1,p2;//p1,p2为ptr类型的指针变量
--------------
附注:
㈠读代码用带入法来理解
typedef int NUM[100];//
NUM xyz;// 相当于 int xyz[100]; 在typedef中将NUM用变量名xyz代替
typedef int (*ptr)();//
ptr p1;//相当于 int (*p1)(); 在typedef中将ptr用变量名p1代替
ptr p1;//相当于 int (*p1)(); 在typedef中将ptr用变量名p1代替
㈡写代码
如果希望int xyz[100];
首先,一般性的描述 int NUM[100];
接着添加头,为typedef int NUM[100];
好处在于
int x[100],y[100],z[100];//不使用
NUM x,y,z;//使用
方便书写代码,并且方便修改程序,一处更新其他地方都更新
如果希望int xyz[100];
首先,一般性的描述 int NUM[100];
接着添加头,为typedef int NUM[100];
好处在于
int x[100],y[100],z[100];//不使用
NUM x,y,z;//使用
方便书写代码,并且方便修改程序,一处更新其他地方都更新
同样
如果希望int (*x)();
首先,一般性的描述 int (*ptr)();
接着添加头,为typedef int (*ptr)();
好处在于
int (*x)(),(*y)(),(*z)();//不使用
ptr x,y,z;//使用
如果希望int (*x)();
首先,一般性的描述 int (*ptr)();
接着添加头,为typedef int (*ptr)();
好处在于
int (*x)(),(*y)(),(*z)();//不使用
ptr x,y,z;//使用