【C语言基础入门】9.C语言中的自定义数据类型
文章目录
一、自定义数据类型（上）
二、自定义数据类型（中）
三、自定义数据类型（下）
一、自定义数据类型（上）
- 类型命名关键字 (typedef)
- C语言中可以对类型赋予新名字
- 语法：typedef Type New TypeName;
- 注意：typedef 并没有创建新类型，只是创建了类型别名
- 深入 typedef 应用
- typedef 可在函数中定义“局部类型名”
- typedef 常用于简化类型名(如: unsigned long long)
- typedef 定义类型名，能够以统一的方式创建变量(Type var; )
下面看一段代码：
#include
typedef unsigned char byte;
void func()
{
typedef byte uint8;
uint8 var = 200;
byte b = var; // 本质为相同类型变量之间的初始化
printf("sizeof(uint8) = %d\n", sizeof(uint8));
printf("var = %d\n", var);
printf("b = %d\n", b);
}
int main()
{
// uint8 var = 1; // ERROR
byte b = 128;
func();
printf("sizeof(byte) = %d\n", sizeof(byte));
printf("b = %d\n", b);
return 0;
}
下面为输出结果：
需要注意：本代码中的 byte 和 uint8 为同一个自定义类型，所以它们之间可以相互赋值。
再来看一段代码：
#include
typedef float(FArr5)[5]; // 定义数组类型名
typedef int(IFuncII)(int, int); // 定义函数类型名
typedef FArr5* PFArr5;
typedef IFuncII* PIFuncII;
float g_arr[5] = {0.1, 0.2, 0.3};
int add(int a, int b)
{
return a + b;
}
int main()
{
FArr5* pa = &g_arr; // float(*)[5]
IFuncII* pf = add; // int(*)(int,int)
PFArr5 npa = pa;
PIFuncII npf = pf;
int i = 0;
for(i=0; i<5; i++)
{
printf("%f\n", (*pa)[i]);
printf("%f\n", (*npa)[i]);
}
printf("%d\n", pf(2, 3));
printf("%d\n", npf(2, 3));
return 0;
}
下面为输出结果：
这里要特别注意函数指针的用法，可以通过 typedef 使得函数指针的定义简化。
- C语言中的结构体（ struct )
- struct 是C语言中的自定义类型关键字
- struct 能够定义不同数据类型变量的集合类型
语法：
struct TypeName
{
Type1 var1;
Type2 var2;
......;
typeN varn;
};
下面看一段代码：
#include
#include
struct Student
{
char name[20];
int id;
short major;
};
int main()
{
struct Student s1 = {"Autumn", 908, 1};
struct Student s2 = s1;
printf("s1.name = %s\n", s1.name);
printf("s1.id = %d\n", s1.id);
printf("s1.major = %d\n", s1.major);
strcpy(s2.name, "Hu");
s2.id = 909;
s2.major = 2;
printf("s2.name = %s\n", s2.name);
printf("s2.id = %d\n", s2.id);
printf("s2.major = %d\n", s2.major);
return 0;
}
下面为输出结果：
- 小结
- C语言中通过 typedef 关键字对数据类型赋予新名字
- typedef 并不会创建一个全新的数据类型
- struct 是C语言中的自定义类型关键字
- struct 用于创建不同数据类型变量的集合类型
二、自定义数据类型（中）
- 深入 struct 结构体类型
- struct 结构体变量的本质是变量的集合
- struct 结构体变量中的成员占用独立的内存
- struct 结构体类型可用 typedef 赋予新类型名
- 可定义struct 结构体类型的指针，并指向对应类型的变量
- struct 结构体类型可先前置声明，再具体定义
- 前置类型声明只能用于指针定义
- 类型完整定义之后才能进行变量定义
- struct 结构体类型可以省略类型名
- 类型名省略时，每次创建变量必须给出完整结构体定义
- struct 结构体类型可以省略类型名（无名结构体类型)
- 类型名省略时，每次创建变量必须给出完整结构体定义
- 无名结构体类型总是互不相同的类型（互不兼容)
先看第1段代码：
#include
#include
typedef struct Student Stu;
struct Student
{
char name[20];
int id;
short major;
};
int main()
{
Stu s;
Stu* ps = &s;
strcpy(ps->name, "Autumn");
ps->id = 1;
ps->major = 908;
(*ps).major = 910; // ==> s.major = 910
printf("s.name = %s\n", s.name);
printf("s.id = %d\n", s.id);
printf("s.major = %d\n", s.major);
return 0;
}
下面为输出结果：
这里注意结构体变量指针通过 -> 操作符访问成员变量。
再看第2段代码：
#include
#include
struct Test;
struct Test* g_pt; // 只要有了类型声明就可以创建对应的指针变量
// 必须先给出类型的完整定义才能创建相应类型的变量
struct Test
{
int a;
int b;
};
int main()
{
struct Test t;
t.a = 1;
t.b = 2;
g_pt = &t;
printf("g_pt = %p\n", g_pt);
printf("g_pt->a = %d\n", g_pt->a);
printf("g_pt->b = %d\n", g_pt->b);
return 0;
}
下面为输出结果：
这里注意两个问题：
1.只要有了类型声明就可以创建对应的指针变量
2.必须先给出类型的完整定义才能创建相应类型的变量
再看第3段代码：
#include
#include
int main()
{
struct { int a, b; } v1;
struct { int a, b; } v2;
struct { int a, b; }*pv;
v1.a = 1;
v1.b = 2;
v2 = v1;
pv = &v2;
return 0;
}
这段代码编译会出错：
这段代码充分说明无名结构体类型总是互不相同的类型（互不兼容)
- 位域
- 现代程序设计中，内存使用的最小单位为字节（约定俗成)
- 在一些特定场合，可将比特位作为最小单位使用内存
- 结构体类型能够指定成员变量占用内存的比特位宽度（位域)
- 深入位域
- 位域成员必须是整型，默认情况下成员依次排列
- 位域成员占用的位数不能超过类型宽度（错误示例: char c : 9; )
- 当存储位不足时，自动启用新存储单元
- 可以舍弃当前未使用的位，重新启用存储单元
下面看一段代码：
#include
struct BW
{
unsigned char a : 4;
unsigned char b : 2;
unsigned char c : 2;
};
int main()
{
struct BW bw = {0};
bw.a = 10;
bw.b = 4; // 4 大于 b 能表示的最大值，因此赋值后 b 回转到 0
bw.c = 3;
printf("sizeof(struct BW) = %d\n", sizeof(struct BW));
printf("bw.a = %d\n", bw.a);
printf("bw.b = %d\n", bw.b);
printf("bw.c = %d\n", bw.c);
return 0;
}
下面为输出结果：
这里注意 a : 4 ，所以 a 的取值范围是 0000 ~ 1111 之间，即 0 ~ 15 之间。
再看一段代码：
#include
#include
struct Bits1
{
int a : 16;
short b : 8;
char c : 8;
float f; // float f : 32; ==> 浮点型成员不能指点位宽度
};
struct Bits2
{
unsigned char a : 6;
unsigned char b : 6;
unsigned char c : 6;
// unsigned char d : 9; ==> 指定的位宽度不能大于声明类型的位宽度
};
struct Bits3
{
unsigned char a : 4;
unsigned char : 0; // 重启一个存储单元表示新的成员
unsigned char b : 4;
};
int main()
{
printf("sizeof(Bits1) = %d\n", sizeof(struct Bits1));
printf("sizeof(Bits2) = %d\n", sizeof(struct Bits2));
printf("sizeof(Bits3) = %d\n", sizeof(struct Bits3));
return 0;
}
下面为输出结果：
这里注意三点：
1.浮点型成员不能指点位宽度
2.指定的位宽度不能大于声明类型的位宽度
3.unsigned char : 0 重启一个存储单元表示新的成员
- 小结
- struct 结构体变量中的成员占用独立的内存
- struct 结构体类型可用 typedef 赋予新类型名
- 结构体类型能够指定成员变量占用内存的比特位宽度
- 位域成员必须是整型，占用的位数不能超过类型宽度
- 当存储位不足时，自动启用新存储单元
三、自定义数据类型（下）
- C语言中的联合体( union )
- union 是C语言中的自定义类型关键字
- union 是 struct 的兄弟关键字，用法上非常相似
语法：
union TypeName
{
Type1 var1;
Type2 var2;
//......
TypeN varn;
};
- union 与 struct 的不同
- union 类型所有成员共享同一段内存(所有成员起始地址相同)
- union 类型的大小取决于成员的最大类型
- union 类型的变量只能以第一个 成员类型的有效值进行初始化
下面看一段代码：
#include
#include
union UTest
{
int a;
float f;
};
struct STest
{
int a;
float f;
};
int main()
{
union UTest ut = {987654321};
struct STest st = {987654321, 0.1f};
printf("union UTest size = %d\n", sizeof(union UTest));
printf("&ut.a = %p\n", &ut.a);
printf("&ut.f = %p\n", &ut.f);
printf("struct STest size = %d\n", sizeof(struct STest));
printf("&st.a = %p\n", &st.a);
printf("&st.f = %p\n", &st.f);
printf("ut.a = %d\n", ut.a);
printf("ut.f = %f\n", ut.f);
ut.f = 987654321.0f;
printf("ut.a = %d\n", ut.a);
printf("ut.f = %f\n", ut.f);
return 0;
}
下面为输出结果：
这里注意整型数据和浮点类型数据在内存中的表示方式不一样，所以在同一段内存，同是4个字节，按照整型的方式解释这4个字节的数据时是一种结果，按照浮点数类型解释这4个字节时就是另一种结果。
- union 类型的应用-判断系统大小端
- 小端系统：低位数据存储在低地址内存中
- 大端系统：低位数据存储在高地址内存中
例如，对于 unsigned ui = 1;
下面看一段判断大小端的代码：
#include
int isLittleEndian()
{
union
{
int i;
char a[4];
} test = {0};
test.i = 1;
return (test.a[0] == 1);
}
int main()
{
printf("System Endian: %d\n", isLittleEndian());
return 0;
}
下面为输出结果：
由代码可知，1 存在低位，所以我的电脑为小端系统。
- C语言中的枚举类型( enum )
- enum 是C语言中的自定义类型关键字
- enum 能够定义整型常量的集合类型
语法：
enum TypeName
{
IntConst1,
IntConst2,
//......
IntconstN
};
- 枚举类型( enum )注意事项
- 第一个枚举常量的默认值为0
- 后续常量的值在前一一个常量值的基础上加1
- 可以任意对枚举常量指定整型值(只能指定整型值)
例如：
下面看一段代码，感受一下：
#include
#include
enum Day { MON = 1, TUE, WED, THU, FRI, SAT, SUN };
enum Season { Spring, Summer = 3, Autumn, Winter = -1 };
enum { CONSTANT = 12345 };
int main()
{
enum Day d = TUE;
enum Season s = Winter;
int i = SUN;
int j = Autumn;
printf("d = %d\n", d); // 2
printf("s = %d\n", s); // -1
printf("i = %d\n", i); // 7
printf("j = %d\n", j); // 4
d = 0;
s = -2;
printf("d = %d\n", d);
printf("s = %d\n", s);
printf("sizeof(enum Day) = %d\n", sizeof(enum Day));
printf("sizeof(enum Season) = %d\n", sizeof(enum Season));
printf("CONSTANT = %d\n", CONSTANT);
// CONSTANT = 54321;
return 0;
}
下面为输出结果：
这段代码也说明了 enum 枚举类型的本质就是整型。
- 小结
- union 是 struct 的兄弟关键字，用法上非常相似
- union 类型所有成员共享同一段内存
- enum 能够定义整型常量的集合类型
- enum 的本质是 int 类型，常用于整型常量定义