C语言 结构体、枚举、联合体(struct 、enum、union)

结构体

在设计程序时，最重要的一个步骤是选择什么数据类型。简单的变量是远远不够的，为此，C语言提供结构变量提高你表示数据的能力，结构体是一种由一序列的成员组成的类型，成员的存储以顺序分配于内存中。

语法:

struct 类型名 // struct book
{
	成员列表;
};

struct book
{
	char title[30]; //书名
	char author[20]; //作者
	float value;//价格
};

引入一个新类型struct book，成员列表可以是基本数据类型，当然也可以是结构体类型，成员列表是结构体类型最常见就是链表中。

struct 类型名
{
	成员列表;
}变量1,变量2,变量3,....等;

struct book
{
	char title[30]; //书名
	char author[20]; //作者
	float value;//价格
}library,bookstore;

在定义结构体类型的时候顺便定义结构体变量，以后还可以定义结构体变量。
例如:
struct book xx;

struct
{ 

 成员列表; 
 
}变量1，变量2;

在定义结构体类型的时候，没有结构体类型名，顺便定义结构体变量， 需要注意的是因为没有类型名，所以不能再定义数据类型。

举例

#include<stdio.h>
#include<stdlib.h>

struct book
{
	char title[30];//书名
	char author[30];//作者
	float value; //价格
};


int main(int argc, char const *argv[])
{

	struct book Lib={"C Primer Plus","Stephen Prata",89.9};
	struct book Boo;
	Boo=Lib;

	printf(" %s  --  %s  --  %f\n",Boo.title,Boo.author,Boo.value );
	return 0;
}

输出结果

enum

枚举是独立的类型，其值限制在一个取值范围内，它可以包含数个明确命名的常量。各常量的值是某个整型类型的值。
枚举类型的目的是为了提高程序的可读性和可维护性。

语法

enum 名字 { 枚举项 = 常量表达式 , 枚举项 = 常量表达式 , ... } 
例如:enum Color { red, green, blue };
							//red=0,green=1,blue=2
							
enum Foo { a, b, c = 10, d, e = 1, f, g = f + c };
				 //a = 0, b = 1, c = 10, d = 11, e = 1, f = 2, g = 12

注意:

不同于 struct 或 union ， C 中没有 enum 的前置声明：

enum Color; // 错误：C 中无 enum 的前置声明
enum Color { RED, GREEN, BLUE};

每个枚举项都与一个底层类型的值相关联。当在 枚举项列表 中提供了初始化器时，各枚举项的值由那些初始化器所定义。若首个枚举项无初始化器，则其关联值为零。对于其他任何定义中无初始化器的枚举项，其关联值为前一枚举项加一。

#include<stdio.h>

enum Color {red=1,green,blue};

int main(int argc, char const *argv[])
{
	
	enum Color r;
	printf("Please enter the color number(1,2,3)\n");
	scanf("%d",&r);
	switch(r)
	{
		case red:
				printf("red\n");
			break;
			
		case green:
				printf("green\n");	
			break;
			
		case blue:
				printf("nlue\n");
			break;	
		
		default:
			printf("There's no color you're looking for\n");	
			break;			

	}

	return 0;
}

union

联合体是由一序列的成员所组成的类型，成员的存储重叠（与结构体相反，结构体是由一序列的成员所构成的类型，成员的存储以顺序分配）。在任一时刻，最多能在联合体中存储其一个成员的值。

联合体的类型指定符与结构体 (struct) 类型指定符相同，只是所用的关键词有别。

语法:

union 联合体名称 
{
	// 	任意数量的变量声明、位域声明和静态断言声明。
};

举例:

#include <stdio.h>
#include <string.h> // strcpy

union Data
{
	int i;
	float f;
	char str[100];
};

int main(int argc, char const *argv[])
{
	
	union Data data;
	char *p = "Cats and dogs are good friends";

	printf("sizeof = %ld\n", sizeof(data));
	data.i = 100;
	data.f = 135.9;
	strcpy(data.str,p);

	printf("data.i = %d\n", data.i);
	printf("data.f = %f\n", data.f);
	printf("data.str = %s\n", data.str);
	return 0;
}

在这里，我们可以看到共用体的 i 和 f 成员的值有损坏，因为最后赋给变量的值占用了内存位置，这也是 str 成员能够完好输出的原因。

#include <stdio.h>
#include <string.h> // strcpy

union Data
{
	int i;
	float f;
	char str[100];
};

int main(int argc, char const *argv[])
{
	
	union Data data;
	char *p = "Cats and dogs are good friends";

	printf("sizeof = %ld\n", sizeof(data));
	data.i = 100;
	printf("data.i = %d\n", data.i);

	data.f = 135.9;
	printf("data.f = %f\n", data.f);
	
	strcpy(data.str,p);
	printf("data.str = %s\n", data.str);
	return 0;
}

float可精度表示至少6位有效数字。在这里，所有的成员都能完好输出，因为同一时间只用到一个成员。

**结构体、枚举、联合体 **

#include <stdio.h>
#include <string.h> // strcpy

struct S
{
	enum {red,green,blue} color;
	union 
	{
		int i;
		char str[100];
		float f;
	};

};

void display(struct S s)
{

	printf("Color Effective range(0,1,2)\n");
	scanf("%d",&s.color);
	switch(s.color)
	{
		case red:
				printf("red\n");
			break;

		case green:
				printf("green\n");	
			break;
			
		case blue:
				printf("blue\n");	
			break;
			
		default:
				printf("error %d value not in range\n",s.color);
			break;			
			
	}

}

int main(int argc, char const *argv[])
{
	struct S s;
	char *p = "Cats and dogs are good friends!";

	printf("sizeof = %ld\n", sizeof(s));

	display(s);
	s.i = 10;
	printf("s.i = %d\n", s.i);
	s.f = 12.5;
	printf("s.f = %f\n", s.f);

	strcpy(s.str,p);
	printf("s.str = %s\n", s.str);
	return 0;
}

扫二维码关注微信公众号，获取技术干货