结构体、枚举、共用体、typedef

最新推荐文章于 2022-05-04 19:51:18 发布

weixin_42639771

最新推荐文章于 2022-05-04 19:51:18 发布

阅读量232

点赞数 1

分类专栏：编程技术

本文链接：https://blog.csdn.net/weixin_42639771/article/details/89527639

版权

编程技术专栏收录该内容

32 篇文章 1 订阅

订阅专栏

一、枚举

枚举类型的定义形式为：

enum typeName
{ 
	valueName1, 
	valueName2, 
	valueName3
 };

例如，列出一个星期有几天：
enum week{ Mon, Tues, Wed, Thurs, Fri, Sat, Sun };
枚举是一种类型，通过它可以定义枚举变量：
enum week a, b, c;
也可以在定义枚举类型的同时定义变量：

enum week
{ 
    Mon = 1, 
    Tues, 
    Wed, 
} a, b, c;

有了枚举变量，就可以把列表中的值赋给它：
enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun };
enum week a = Mon, b = Wed, c = Sat;
或者：

enum week
{ 
Mon = 1, 
Tues, 
Wed, 
Thurs, 
} a = Mon, b = Wed;

枚举类型总结：
需要注意的两点是：

枚举列表中的 Mon、Tues、Wed 这些标识符的作用范围是全局的（严格来说是 main() 函数内部），不能再定义与它们名字相同的变量。
Mon、Tues、Wed 等都是常量，不能对它们赋值，只能将它们的值赋给其他的变量。

枚举和宏其实非常类似：宏在预处理阶段将名字替换成对应的值，枚举在编译阶段将名字替换成对应的值。我们可以将枚举理解为编译阶段的宏。

对于上面的代码，在编译的某个时刻会变成类似下面的样子：

#include <stdio.h>

int main()
{
    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } day;
    scanf("%d", &day);
    switch(day){
        case 1: puts("Monday"); break;
        case 2: puts("Tuesday"); break;
        case 3: puts("Wednesday"); break;
        case 4: puts("Thursday"); break;
        case 5: puts("Friday"); break;
        case 6: puts("Saturday"); break;
        case 7: puts("Sunday"); break;
        default: puts("Error!");
    }
    return 0;
}

Mon、Tues、Wed 这些名字都被替换成了对应的数字。这意味着，Mon、Tues、Wed 等都不是变量，它们不占用数据区（常量区、全局数据区、栈区和堆区）的内存，而是直接被编译到命令里面，放到代码区，所以不能用&取得它们的地址。这就是枚举的本质。
我们在《C语言switch case语句》一节中讲过，case 关键字后面必须是一个整数，或者是结果为整数的表达式，但不能包含任何变量，正是由于 Mon、Tues、Wed 这些名字最终会被替换成一个整数，所以它们才能放在 case 后面。

枚举类型变量的长度
枚举变量需要存放的是一个整数，所以它的长度和 int 应该相同：

int main()
{
    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } day = Mon;
    printf("%d, %d, %d, %d, %d\n", sizeof(enum week), sizeof(day), sizeof(Mon), sizeof(Wed), sizeof(int) );
    return 0;
}

运行结果：

4, 4, 4, 4, 4

枚举变量的值是整数，所有可以为负整数。

enum test
{
    VAL_ZERO = -2,
    VAL_ONE,
    VAL_TWO,
    VAL_THREE
};
int main(void) 
{ 
    enum test t1 = VAL_ZERO, t2 = VAL_THREE;
    printf("t1 = %d\n", t1);
    printf("t2 = %d\n", t2);
    printf("sizeof t1 = %ld\n", sizeof(t1));
	return 0;
}
t1 = -2
t2 = 1
sizeof t1 = 4

二、结构体

可以在定义结构体的同时定义结构体变量：

struct stu{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在学习小组
    float score;  //成绩
} stu1, stu2;

如果只需要 stu1、stu2 两个变量，后面不需要再使用结构体名定义其他变量，那么在定义时也可以不给出结构体名，如下所示：

struct{  //没有写 stu
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在学习小组
    float score;  //成绩
} stu1, stu2;

这样做书写简单，但是因为没有结构体名，后面就没法用该结构体定义新的变量。
除了可以对成员进行逐一赋值，也可以在定义时整体赋值，例如：

struct{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在小组
    float score;  //成绩
} stu1, stu2 = { "Tom", 12, 18, 'A', 136.5 };

不过整体赋值仅限于定义结构体变量的时候，在使用过程中只能对成员逐一赋值，这和数组的赋值非常类似。
需要注意的是，结构体是一种自定义的数据类型，是创建变量的模板，不占用内存空间；结构体变量才包含了实实在在的数据，需要内存空间来存储。
在C语言中，定义结构体数组和定义结构体变量的方式类似，请看下面的例子：

struct stu{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在小组 
    float score;  //成绩
}class[5];

也可以在定义结构体的同时定义结构体指针：

struct stu{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在小组
    float score;  //成绩
} stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;

注意，结构体变量名和数组名不同，数组名在表达式中会被转换为数组指针，而结构体变量名不会，无论在任何表达式中它表示的都是整个集合本身，要想取得结构体变量的地址，必须在前面加&，所以给 pstu 赋值只能写作：
struct stu *pstu = &stu1;
而不能写作：
struct stu *pstu = stu1;
【示例】结构体指针的使用。

#include <stdio.h>
int main(){
    struct{
        char *name;  //姓名
        int num;  //学号
        int age;  //年龄
        char group;  //所在小组
        float score;  //成绩
    } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;

    //读取结构体成员的值
    printf("%s的学号是%d，年龄是%d，在%c组，今年的成绩是%.1f！\n", (*pstu).name, (*pstu).num, (*pstu).age, (*pstu).group, (*pstu).score);
    printf("%s的学号是%d，年龄是%d，在%c组，今年的成绩是%.1f！\n", pstu->name, pstu->num, pstu->age, pstu->group, pstu->score);

    return 0;
}

【示例】结构体数组指针的使用

#include <stdio.h>

struct stu{
    char *name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在小组
    float score;  //成绩
}stus[] = {
    {"Zhou ping", 5, 18, 'C', 145.0},
    {"Zhang ping", 4, 19, 'A', 130.5},
    {"Liu fang", 1, 18, 'A', 148.5},
    {"Cheng ling", 2, 17, 'F', 139.0},
    {"Wang ming", 3, 17, 'B', 144.5}
}, *ps;

int main(){
    //求数组长度
    int len = sizeof(stus) / sizeof(struct stu);
    printf("Name\t\tNum\tAge\tGroup\tScore\t\n");
    for(ps=stus; ps<stus+len; ps++){
        printf("%s\t%d\t%d\t%c\t%.1f\n", ps->name, ps->num, ps->age, ps->group, ps->score);
    }

    return 0;
}

三、共用体

结构体和共用体的区别在于：结构体的各个成员会占用不同的内存，互相之间没有影响；而共用体的所有成员占用同一段内存，修改一个成员会影响其余所有成员。

结构体占用的内存大于等于所有成员占用的内存的总和（成员之间可能会存在缝隙），共用体占用的内存等于最长的成员占用的内存。共用体使用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会把原来成员的值覆盖掉。
共用体也是一种自定义类型，可以通过它来创建变量，例如：

union data{
    int n;
    char ch;
    double f;
};

union data a, b, c;
也可以在定义共用体的同时创建变量：

union data{
    int n;
    char ch;
    double f;
} a, b, c;

如果不再定义新的变量，也可以将共用体的名字省略：

union{
    int n;
    char ch;
    double f;
} a, b, c;

共用体 data 中，成员 f 占用的内存最多，为 8 个字节，所以 data 类型的变量（也就是 a、b、c）也占用 8 个字节的内存，请看下面的演示：

#include <stdio.h>

union data{
    int n;
    char ch;
    short m;
};

int main(){
    union data a;
    printf("%d, %d\n", sizeof(a), sizeof(union data) );
    a.n = 0x40;
    printf("%X, %c, %hX\n", a.n, a.ch, a.m);
    a.ch = '9';
    printf("%X, %c, %hX\n", a.n, a.ch, a.m);
    a.m = 0x2059;
    printf("%X, %c, %hX\n", a.n, a.ch, a.m);
    a.n = 0x3E25AD54;
    printf("%X, %c, %hX\n", a.n, a.ch, a.m);
   
    return 0;
}
运行结果：
4, 4
40, @, 40
39, 9, 39
2059, Y, 2059
3E25AD54, T, AD54

这段代码不但验证了共用体的长度，还说明共用体成员之间会相互影响，修改一个成员的值会影响其他成员。
要想理解上面的输出结果，弄清成员之间究竟是如何相互影响的，就得了解各个成员在内存中的分布。以上面的 data 为例，各个成员在内存中的分布如下：
在这里插入图片描述

成员 n、ch、m 在内存中“对齐”到一头，对 ch 赋值修改的是前一个字节，对 m 赋值修改的是前两个字节，对 n 赋值修改的是全部字节。也就是说，ch、m 会影响到 n 的一部分数据，而 n 会影响到 ch、m 的全部数据。

上图是在绝大多数 PC 机上的内存分布情况，如果是 51 单片机，情况就会有所不同：
在这里插入图片描述

为什么不同的机器会有不同的分布情况呢？这跟机器的存储模式有关，我们将在VIP教程《大端小端以及判别方式》一节中展开探讨。
共用体的应用

共用体在一般的编程中应用较少，在单片机中应用较多。对于 PC 机，经常使用到的一个实例是：现有一张关于学生信息和教师信息的表格。学生信息包括姓名、编号、性别、职业、分数，教师的信息包括姓名、编号、性别、职业、教学科目。请看下面的表格：http://c.biancheng.net/view/2035.html

四、typedef

typedef和define区别，C语言typedef和define的区别详解
typedef 是用来定义一种类型的新别名的，它不同于宏（#define），不是简单的字符串替换。它的新名字具有一定的封装性，所以新命名的标识符具有更易定义变量的功能，它是语言编译过程的一部分，但它并不实际分配内存空间。

而 #define 只是简单的字符串替换（原地扩展），它本身并不在编译过程中进行，而是在这之前（预处理过程）就已经完成了。因此，它不会做正确性检查，不管含义是否正确它照样会带入，只有在编译已被展开的源程序时才会发现可能的错误并报错。

接下来看下面的示例代码：

typedef char * PCHAR1;
#define PCHAR2 char *……

/* c1、c2 都为char *，typedef为char 引入了一个新的别名/
PCHAR1 c1, c2；
/*相当于char * c3， c4；c3是char ，而c4是char /
PCHAR2 c3, c4；
在定义上述的变量时，c1、c2 与 c3 按照预期都被定义成 char 类型。值得注意的是，c4 却被定义成 char 类型，而不是我们所预期的 char。其根本原因就在于 #define 只是简单的字符串替换，而 typedef 则是为一个类型引入一个新的别名。
C语言允许用户使用 typedef 关键字来定义自己习惯的数据类型名称，来替代系统默认的基本类型名称、数组类型名称、指针类型名称与用户自定义的结构型名称、共用型名称、枚举型名称等。一旦用户在程序中定义了自己的数据类型名称，就可以在该程序中用自己的数据类型名称来定义变量的类型、数组的类型、指针变量的类型与函数的类型等。

例如，C 语言在 C99 之前并未提供布尔类型，但我们可以使用 typedef 关键字来定义一个简单的布尔类型，如下面的代码所示：
typedef int BOOL;
#define TRUE 1
#define FALSE 0
定义好之后，就可以像使用基本类型数据一样使用它了，如下面的代码所示：
BOOL bflag=TRUE;

typedef的4种用法

在实际使用中，typedef 的应用主要有如下4种。

1. 为基本数据类型定义新的类型名

也就是说，系统默认的所有基本类型都可以利用 typedef 关键字来重新定义类型名，示例代码如下所示：
typedef unsigned int COUNT;
而且，我们还可以使用这种方法来定义与平台无关的类型。比如，要定义一个叫 REAL 的浮点类型，在目标平台一上，让它表示最高精度的类型，即：
typedef long double REAL;
在不支持 long double 的平台二上，改为：

typedef double REAL;
这样，当跨平台移植程序时，我们只需要修改一下 typedef 的定义即可，而不用对其他源代码做任何修改。其实，标准库中广泛地使用了这个技巧，比如 size_t 在 VC++2010 的 crtdefs.h 文件中的定义如下所示：
#ifndef _SIZE_T_DEFINED
#ifdef _WIN64
typedef unsigned __int64 size_t;
#else
typedef _W64 unsigned int size_t;
#endif
#define _SIZE_T_DEFINED
#endif

2. 为自定义数据类型（结构体、共用体和枚举类型）定义简洁的类型名称

以结构体为例，下面我们定义一个名为 Point 的结构体：
struct Point
{
double x;
double y;
double z;
};
在调用这个结构体时，我们必须像下面的代码这样来调用这个结构体：
struct Point oPoint1={100，100，0};
struct Point oPoint2;
在这里，结构体 struct Point 为新的数据类型，在定义变量的时候均要向上面的调用方法一样有保留字 struct，而不能像 int 和 double 那样直接使用 Point 来定义变量。现在，我们利用 typedef 定义这个结构体，如下面的代码所示：

typedef struct tagPoint
{
    double x;
    double y;
    double z;
} Point;

在上面的代码中，实际上完成了两个操作：
1、定义了一个新的结构类型，代码如下所示：
struct tagPoint
{
double x;
double y;
double z;
} ;
其中，struct 关键字和 tagPoint 一起构成了这个结构类型，无论是否存在 typedef 关键字，这个结构都存在。

2、使用 typedef 为这个新的结构起了一个别名，叫 Point，即：
typedef struct tagPoint Point
因此，现在你就可以像 int 和 double 那样直接使用 Point 定义变量，如下面的代码所示：
Point oPoint1={100，100，0};
Point oPoint2;
为了加深对 typedef 的理解，我们再来看一个结构体例子，如下面的代码所示：

typedef struct tagNode
{
    char *pItem;
    pNode* pNext;
} *pNode;

从表面上看，上面的示例代码与前面的定义方法相同，所以应该没有什么问题。但是编译器却报了一个错误，为什么呢？莫非 C 语言不允许在结构中包含指向它自己的指针？

其实问题并非在于 struct 定义的本身，大家应该都知道，C 语言是允许在结构中包含指向它自己的指针的，我们可以在建立链表等数据结构的实现上看到很多这类例子。那问题在哪里呢？其实，根本问题还是在于 typedef 的应用。

在上面的代码中，新结构建立的过程中遇到了 pNext 声明，其类型是 pNode。这里要特别注意的是，pNode 表示的是该结构体的新别名。于是问题出现了，在结构体类型本身还没有建立完成的时候，编译器根本就不认识 pNode，因为这个结构体类型的新别名还不存在，所以自然就会报错。因此，我们要做一些适当的调整，比如将结构体中的 pNext 声明修改成如下方式：

typedef struct tagNode
{
    char *pItem;
    struct tagNode *pNext;
} *pNode;

或者将 struct 与 typedef 分开定义，如下面的代码所示：

typedef struct tagNode *pNode;
struct tagNode
{
    char *pItem;
    pNode pNext;
};

在上面的代码中，我们同样使用 typedef 给一个还未完全声明的类型 tagNode 起了一个新别名。不过，虽然 C 语言编译器完全支持这种做法，但不推荐这样做。建议还是使用如下规范定义方法：

struct tagNode
{
    char *pItem;
    struct tagNode *pNext;
};
typedef struct tagNode *pNode;

3. 为数组定义简洁的类型名称

它的定义方法很简单，与为基本数据类型定义新的别名方法一样，示例代码如下所示：
typedef int INT_ARRAY_100[100];
INT_ARRAY_100 arr;

4. 为指针定义简洁的名称

对于指针，我们同样可以使用下面的方式来定义一个新的别名：
typedef char* PCHAR;
PCHAR pa;
对于上面这种简单的变量声明，使用 typedef 来定义一个新的别名或许会感觉意义不大，但在比较复杂的变量声明中，typedef 的优势马上就体现出来了，如下面的示例代码所示：
int *(a[5])(int,char);
对于上面变量的声明，如果我们使用 typdef 来给它定义一个别名，这会非常有意义，如下面的代码所示：
// PFun是我们创建的一个类型别名
typedef int (PFun)(int,char);
// 使用定义的新类型来声明对象，等价于int(a[5])(int,char);
PFun a[5];
小心使用 typedef 带来的陷阱

接下来看一个简单的 typedef 使用示例，如下面的代码所示：
typedef char* PCHAR;
int strcmp(const PCHAR,const PCHAR);
在上面的代码中，“const PCHAR” 是否相当于 “const char*” 呢？

答案是否定的，原因很简单，typedef 是用来定义一种类型的新别名的，它不同于宏，不是简单的字符串替换。因此，“const PCHAR”中的 const 给予了整个指针本身常量性，也就是形成了常量指针“charconst（一个指向char的常量指针）”。即它实际上相当于“charconst”，而不是“const char*（指向常量 char 的指针）”。当然，要想让 const PCHAR 相当于 const char* 也很容易，如下面的代码所示：
typedef const char* PCHAR;
int strcmp(PCHAR， PCHAR);
其实，无论什么时候，只要为指针声明 typedef，那么就应该在最终的 typedef 名称中加一个 const，以使得该指针本身是常量。

还需要特别注意的是，虽然 typedef 并不真正影响对象的存储特性，但在语法上它还是一个存储类的关键字，就像 auto、extern、static 和 register 等关键字一样。因此，像下面这种声明方式是不可行的：
typedef static int INT_STATIC;
不可行的原因是不能声明多个存储类关键字，由于 typedef 已经占据了存储类关键字的位置，因此，在 typedef 声明中就不能够再使用 static 或任何其他存储类关键字了。当然，编译器也会报错，如在 VC++2010 中的报错信息为“无法指定多个存储类”。

weixin_42639771

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
结构体、枚举、共用体、typedef

一、枚举枚举类型的定义形式为：enum typeName{ valueName1, valueName2, valueName3, … };例如，列出一个星期有几天：enum week{ Mon, Tues, Wed, Thurs, Fri, Sat, Sun };枚举是一种类型，通过它可以定义枚举变量：enum week a, b, c;也可以在定义枚举类型的同时定义变量：enu...
复制链接

扫一扫