目录
1、什么是结构体

2、结构的定义

3、结构体变量的定义和初始化

4、结构体内存对齐

5、结构体传参

6、位段
1、什么是结构体？

定义：结构体是一系列数据的集合.这些数据可能描述了一个物体，也可能是对一个问题的抽象。
一般在什么情况下用到结构体


a、一般当内置内存无法满足用户需要，没有合适类型对应对象时，需要封装特定的类型

b、当函数有多个参数时，返回值过多，需要封装特定类型，将参数打包返回。

2、结构的声明
struct tag//j结构体名
{
member-list;//成员变量列表
}variable-list;//结构体变量列表

举个例子，简单的说，对于学生，有名字，性别，年龄，学号等个人信息，那么，我们在定义这种个体的时候，就不能说它能用一个字符或整型变量来定义。 这时候，就需要结构体了。
struct Stu
{
	char name[20];//名字 
	int age;//年龄
	char sex[5];//性别 
	char id[20];//学号
}；//分号不能丢


特殊的声明

在声明结构的时候，可以不完全的声明。 比如：

//匿名结构体类型 struct
{
	int a; 
	char b; 
	float c;
}x; 
struct
{
	int a; 
	char b; 
	float c;
}a[20], *p;

上面的两个结构在声明的时候省略掉了结构体标签（tag）。那么问题来了？

//在上面代码的基础上，下面的代码合法吗？

p = &x;

警告：  编译器会把上面的两个声明当成完全不同的两个类型。  所以是非法的
2、结构的定义
在结构中包含一个类型为该结构本身的成员是否可以呢？
错误的自引用：
//代码1 struct Node
{
	int data;
	struct Node next;
};
//可行否？
如果可以，那sizeof(struct Node)是多少？

正确的自引用方式：
//代码2 struct Node
{
	int data;
	struct Node* next;
};

注意：
//代码3
typedef struct
{
int data; Node* next;
}Node;
//这样写代码，可行否？

//解决方案：
typedef struct Node
{
int data;
struct Node* next;
}Node;

3、结构体变量的定义和初始化
有了结构体类型，那如何定义变量，其实很简单。

定义：

struct Point
{
int x; int y;
}p1;                 //声明类型的同时定义变量p1
struct Point p2;      //定义结构体变量p2



初始化

struct Stu
{
	char name[15];//名字
	int age;	//年龄
};


//初始化：定义变量的同时赋初值。
struct Stu s = {"zhangsan", 20};//初始化


//结构体嵌套初始化
truct Node
{
	int data; struct Point p;
	struct Node* next;
}n1 = {10, {4,5}, NULL};//结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化	

4、结构体内存对齐
1.什么是结构体内存对齐？为什么要对齐？怎样对齐？
结构体内存对齐：元素是按照定义顺序一个一个放到内存中去的，但并不是紧密排列的。从结构体存储的首地址开始，每个元素放置到内存中时，它都会认为内存是按照自己的大小来划分的，因此元素放置的位置一定会在自己宽度的整数倍上开始。

例：
 struct   A
{
	int a;
	char b;
	double c;
	char d;
};

在32位编译系统下这一个结构体的字节数是多少呢？是4+1+8+1=14字节吗？

让我们来看看结果：



解析：

在windows系统32位平台上:

int占4个字节

char占1个字节

float占4个字节

double占8个字节

int a从0偏移开始，占四个字节，即占用0，1，2，3，现在可用偏移为4偏移，接下来存char b; 由于4是1的倍数，故而，b占用4偏移，接下来可用偏移为5偏移，接下来该存double c; 由于5不是8的倍数，所以向后偏移5，6，7，都不是8的倍数，偏移到8时，8是8的倍数，故而c从8处开始存储，占用8，9，10，11，12，13，14，15偏移，现在可用偏移为16偏移，最后该存char d ;因为16是1的倍数，故d占用16偏移，接下来在整体向后偏移一位，现处于17偏移，min(默认对齐参数，类型最大字节数)=8；因为17不是8的倍数，所以继续向后偏移18…23都不是8的倍数，到24偏移处时，24为8的整数倍，故而，该结构体大小为24个字节。



为什么要对齐？

平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因再与，为了访问未对齐的内存，处理器需要作两次内存访问，而对于对齐的内存访问仅需要一次访问。

结构体的对齐规则：

第一个成员在与结构体变量偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

对齐数 =  编译器默认的一个对齐数 与 该成员大小的较小值。

VS中默认的值为8 Linux中的默认值为4
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所 有最大对齐数（含嵌套结构体的对齐数）的整数倍。

对齐参数不能任意设置，只能是内置类型已有的字节数，如：char(1)、short（2），int（4），double(8)…不能是3，5…任意数。

（5）、如何知道结构体某个成员相对于结构体起始位置的偏移量？

使用offsetof宏来判断结构体中成员的偏移地址。使用offsetof宏需要包含stddef.h头文件，该宏定义如下:
#define offsetof(type,menber) (size_t)&(((type*)0)->member)

1

2

巧妙之处在于将地址0强制转换为type类型的指针，从而定位到member在结构体中偏移位置，编译器认为0是一个有效的地址，从而认为0是type指针的起始地址。

2.修改默认对齐数

之前我们见过了  #pragma  这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。
#include <stdio.h>
#pragma pack(8)//设置默认对齐数为8 struct S1
{
	char c1; int i; char c2;
};
#pragma  pack()//取消设置的默认对齐数，还原为默认

#pragma pack(1)//设置默认对齐数为8 struct S2
{
	char c1; int i; char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认 int main()
{
	//输出的结果是什么？
	printf("%d\n", sizeof(struct S1)); printf("%d\n", sizeof(struct S2)); return 0;
}

结论：

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。
3.如何知道结构体某个成员相对于结构体起始位置的偏移量？

使用offsetof宏来判断结构体中成员的偏移地址。使用offsetof宏需要包含stddef.h头文件，该宏定义如下:
   #define offsetof(type,menber) (size_t)&(((type*)0)->member)

巧妙之处在于将地址0强制转换为type类型的指针，从而定位到member在结构体中偏移位置，编译器认为0是一个有效的地址，从而认为0是type指针的起始地址。
5、结构体传参
struct S
{
 int data[1000]; int num;
};
struct S s = {{1,2,3,4}, 1000};

//结构体传参
void print1(struct S s)
{
 printf("%d\n",s.num);
}

//结构体地址传参
void print2(struct S* ps)
{
 printf("%d\n",ps->num);
}

int main()
{
	print1(s);	//传结构体 
	print2(&s); //传地址 return 0;
}

上面的 print1 和 print2 函数哪个好些？

答案是：首选print2函数。 原因： 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

结论：  结构体传参的时候，要传结构体的地址。
6、位段
结构体讲完就得讲讲结构体实现 位段 的能力。

1.什么是位段:  位段的声明和结构是类似的，有两个不同：

位段的成员必须是 int、unsigned int 或signed int 。
位段的成员名后边有一个冒号和一个数字。

例如：
struct A
{
	int _a:2; 
	int _b:5; 
	int _c:10; 
	int _d:30;
};

A就是一个位段类型。那位段A的大小是多少？
printf("%d\n", sizeof(struct A));

结果：



位段的内存分配

位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

举个例子：
//一个例子
struct S
{
	char a:3;
	char b:4;
	char c:5;
	char d:4;
};
struct S s = {0};
s.a=10;
s.b=12;
s.c=3;
s.d=4;

空间是如何开辟的？



位段的跨平台问题

int 位段被当成有符号数还是无符号数是不确定的。
位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位 还是利用，这是不确定的。

总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
位段的应用：

结构体可以同时存储多种变量类型，而共同体同一个时间只能存储和使用多个变量类型的一种，当另一时间，变量类型被改变后，原来的变量类型和值将被舍弃。共用体的作用是同一个数据项可以使用多种格式，可以节省空间。比如，对商品进行标识时可以用整数和字符串中的一个。

如果union里面含有用户定义的类时，包括string和vector等STL里的类， 在进行类型转换时，需要把原有的类型先析构掉。

 

参考:https://blog.csdn.net/Whity_Yuan/article/details/79658301

常量
语法：
const 类型 常量名 = 值；
在定义时赋值，在其他地方不能赋值

枚举
我们自己定义的一种数据类型，并且在定义时要指定这种类型包含的全部值。

枚举的定义一般与类在同一级别。这样在同一个命名空间下的所有类都可以使用这个枚举。
作用：
1. 限制用户对枚举类型变量的赋值只能是枚举出的值，不能是其他值（规范统一）
2. 当枚举类型特别多，赋值时不需要用户全部记住，可通过点选进行赋值（gender.男）
语法：
enum 自己起的类型名称{值1，值2，值3....值n}；
例子如下：
enum gender{男，女};     //定义了一个gender类型（父类型是枚举类型），定义时不需要引号
gender sex；	//声明sex为gender类型（类似于声明一个整型：int x；）
sex = gender.男；	//此处只能写枚举内定义好的值
sexsx = （int）sex；	//此时sexsx = 0


注意：

定义枚举类型时值不能是int类型；

但枚举类型的变量可以强制转化为int类型，

转化后的int值为定义枚举时的顺序，第一个数为0第二个数为1，依次类推
将字符串类型转化为枚举类型：

语法：
(自定义的枚举类型)(Enum.Parse(typeof(自定义的枚举类型)，“待转换的字符串”));
string s = Console.ReadLine();	//读取用户输入的字符串 
try
{
	(gender)(Enum.Parse(typeof(gender)，“待转换的字符串”));			//字符串化为枚举
	Console.Wrintline("转化成功！")
}
catch
{
	Console.Wrintline("转化失败！")；
}
注意：上式字符串值必须在枚举中有相同值才能转化成功，否则依然会转化失败

结构体
用于将不同类型的数据存储为一类，有点像python中的字典

比如：大果同学有姓名（str）、年龄（int）、分数（int）、电话（str）等等信息，我们要将它归为一组

语法：

访问修饰符 struct 结构名

{

定义结构成员	

}
public struct person		//public是访问修饰符的一种；结构名为person
{
	public string Name;
	public int age;
	public string hobby
}

上面我们定义好了一个叫做person的结构体类型

定义好之后，就可以和其他类型一样，进行声明和赋值咯

声明赋值好之后就可以通过变量名.成员名来访问结构体成员

下面我们来看看怎么使用他
//定义
public struct person		//public是访问修饰符的一种；结构名为person
{
	public string name;
	public int age;
	public string hobby
}
//声明和赋值
person xiaoming;		//person:类型；xiaoming：变量名
xiaoming.name = "小明";
xiaoming.age = "18";
xiaomign.hobby = "basketball";

person xiaohua;
xiaohua.name = "小华";
xiaohua.age = "19";
xiaohua.hobby = "football";

person xiaohei;
xiaohei.name = "小黑";
xiaohei.age = "12";
xiaohei.hobby = "ball";

当用户在PHP中调用一个函数或者类的方法时，内核会创建一个新的符号表并激活之，这也就是为什么我们无法在函数中使用在函数外定义的变量的原因（因为它们分属两个符号表，一个当前作用域的，一个全局作用域的）。如果不是在一个函数里，则全局作用域的符号表处于激活状态。
我们现在打开Zend/zend_globals.h文件，看一下_zend_execution_globals结构体，会在其中发现这么两个element：
struct _zend_executor_globals {
    ...
    HashTable symbol_table;
    HashTable *active_symbol_table;
    ...
};
其中的 symbol_table元素可以通过EG宏来访问，它代表着PHP的全局变量，如$GLOBALS，其实从根本上来讲，$GLOBALS不过是EG(symbol_table)的一层封装而已。EG宏在Zend\zend_globals_macros在被定义：
/* Executor */
#ifdef ZTS
# define EG(v) TSRMG(executor_globals_id, zend_executor_globals *, v)
#else
# define EG(v) (executor_globals.v)
extern ZEND_API zend_executor_globals executor_globals;
#endif
 symbol_table和active_symbol_table在_zend_executor_globals里虽然都代表HashTable，但一个是真正的HashTable，而另一个是一个指针。当
我们在对HashTable进行操作的时候，往往是把它的地址传递给一些函数。所以，如果我们要对EG(symbol_table)的结果进行操作，往往
需要对它进行求址操作然后用它的地址作为被调用函数的参数。
下面我们用一段例子来解释下上面说的理论：
<?php
$foo = 'bar';
?>
 
上面是一段PHP语言的例子，我们创建了一个变量，并把它的值设置为'bar'，在以后的代码中我们便可以使用$foo变量。相同的功能我们怎样在内核中实现呢？我们可以先构思一下步骤：
创建一个zval结构，并设置其类型。
设置值为'bar'。
将其加入当前作用域的符号表，只有这样用户才能在PHP里使用这个变量。
具体的代码为：.
{
    zval *fooval;

    MAKE_STD_ZVAL(fooval);
    ZVAL_STRING(fooval, "bar", 1);
    ZEND_SET_SYMBOL( EG(active_symbol_table) ,  "foo" , fooval);
}
 
首先，我们声明一个zval指针，并申请一块内存。然后通过ZVAL_STRING宏将值设置为‘bar’,最后一行的作用就是将这个zval加入到当前的符号表里去，并将其label定义成foo，这样用户就可以在代码里通过$foo来使用它了。
以下是用的宏：
#define MAKE_STD_ZVAL(zv)				 \
	ALLOC_ZVAL(zv); \
	INIT_PZVAL(zv);

/* fast cache for zval's */
#define ALLOC_ZVAL(z)	\
	(z) = (zval *) emalloc(sizeof(zval))

#define INIT_PZVAL(z)		\
	(z)->refcount__gc = 1;	\
	(z)->is_ref__gc = 0;

#define ZVAL_STRING(z, s, duplicate) do {	\
		const char *__s=(s);				\
		zval *__z = (z);					\
		Z_STRLEN_P(__z) = strlen(__s);		\
		Z_STRVAL_P(__z) = (duplicate?estrndup(__s, Z_STRLEN_P(__z)):(char*)__s);\
		Z_TYPE_P(__z) = IS_STRING;			\
	} while (0)

#define ZEND_SET_SYMBOL(symtable, name, var)										\
	{																				\
		char *_name = (name);														\
																					\
		ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var, 1, 0);	\
	}

#define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref)				\
	{																									\
		zval **orig_var;																				\
																										\
		if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS				\
			&& PZVAL_IS_REF(*orig_var)) {																\
			Z_SET_REFCOUNT_P(var, Z_REFCOUNT_PP(orig_var));												\
			Z_SET_ISREF_P(var);																			\
																										\
			if (_refcount) {																			\
				Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount - 1);								\
			}																							\
			zval_dtor(*orig_var);																		\
			**orig_var = *(var);																		\
			FREE_ZVAL(var);																				\
		} else {																						\
			Z_SET_ISREF_TO_P(var, _is_ref);																\
			if (_refcount) {																			\
				Z_SET_REFCOUNT_P(var, _refcount);														\
			}																							\
			zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL);			\
		}																								\
	}