c++学习9 结构体

一 结构体赋值

结构体赋值的方法有三种，逐个成员赋值，整体赋值和拷贝赋值。

设一个结构体有struck student{ int age;char ch[32]; }；

逐个成员赋值：student tony={16,"tony"};

整体赋值：student lucy；lucy=tony。//相同类型的结构体才可以这么做。

拷贝赋值：#include<string.h>;memcpy(&lucy,&tony,sizeof(student));

二 结构体数组

本质是数组，只是数组的每个元素为以结构体。

struck student{ int age;char ch[32]; }；

student arr[5]={{12,"wbh"},{14,"lyq"},{16,"sh"},{18,"sb"},{19,"kk"}}.

三 结构体指针变量

结构体指针变量的本质是一个变量，只不过该变量保存的内容是结构体的地址。

结构体输出：cout<<结构体成员 . 数据类型<<endl;

指针输出：cout<<(*p).数据类型<<endl;cout<<p->数据类型<<endl;cout<<(&结构体成员)->数据类型<<endl;

四 结构体数组元素的指针变量

指针变量，保存结构体数组元素的地址。

通过指针变量，可以用->来访问结构体元素内容；

五 结构体的指针成员

浅拷贝和深拷贝的区别：

浅拷贝：就是直接带入相等，很死板的机械复制同一个维度空间的内容。

void test08()
{
    student wbh;
    wbh.age = 19;
    wbh.name = new char[32];
    strcpy(wbh.name, "wangbohan");
    cout << "姓名:" << (&wbh)->name << endl << "年龄:" << (&wbh)->age;
    student lyq;
    lyq = wbh;//这就是浅拷贝。
    delete[]lyq.name;//第一次释放new char[32];
    delete[]wbh.name;//第二次释放new char[32],重复释放内存空间，这就是在有指针变量的前提下浅拷贝带来的缺点。
}

深拷贝：深拷贝可以避免浅拷贝里的内存空间重复释放的问题，解决方法也很直接，就是在第二个结构体里重新申请一个内存空间，然后利用strcpy（）函数来拷贝内存空间内容。

 1 void test08()
 2 {
 3     student wbh;
 4     wbh.age = 19;
 5     wbh.name = new char[32];
 6     strcpy(wbh.name, "wangbohan");
 7     cout << "姓名:" << (&wbh)->name << endl << "年龄:" << (&wbh)->age;
 8     student lyq;
 9     lyq = wbh;//这就是浅拷贝。
10     delete[]lyq.name;//第一次释放new char[32];
11     delete[]wbh.name;//第二次释放new char[32],重复释放内存空间，这就是在有指针变量的前提下浅拷贝带来的缺点。
12     student ljj;
13     ljj.age = 26;
14     ljj.name = new char[32];//ljj这个指针成员，我们专门为了她重新申请了一个堆区内存空间。
15     strcpy(ljj.name, wbh.name);//所以我们没有直接用等号赋值法，而是运用了函数strcpy()来赋值。
16     delete[]ljj.name;//释放 另 一 个 内存空间，而不是重复调用导致的反复释放。
17 }

六 结构体变量在堆区，结构体的指针成员也指向堆区

其实就是把结构体本身存储在文字常量区里，然后通过指针去申请内存空间，把结构体这个变量本身放在堆区里。

废话不多说，上代码：

1 void test09()
2 {
3     student* p;//结构体在指针。
4     p = new student;//在堆区里申请一个结构体的空间,注意哦！必须要前后结构实体一致，不然会分配失败
5     //错误示范：
6     //p = new massage;
7     p->name = new char[32];
8     strcpy(p->name, "wangbohan");
9 }

七 结构体的对齐规则

结构体有一个自己的、默认的对齐规则，用来提高读取速率和处理速度的，但是会浪费空间。

（也就是典型的用空间换取时间的例子）

ps：上图中“CPU一次性提取4字节”是一个假设。

自动对齐规则：

1.确定分配单位（一行分配多少字节）由结构体中最大的基本类型的长度决定；

2.确定成员的偏移量——成员偏移量==成员自身类型的整数倍；

3.收尾工作——结构体的总大小==分配单位的整数倍。

强制对齐规则： 

#pragma pack(value) 时指定对齐值为value。value的值分为：1，2，4，8，16。

1.确定分配单位（一行分配多少字节）

分配单位=min（结构体中最大的基本类型，value）；

2.确定成员的偏移量

成员偏移量==成员自身类型的整数倍；

3.收尾工作：结构体的总大小==value的整数倍。

八 结构体的位域

在结构体中，以位为单位的成员，称之为位域。

本来应该是至少三个字节的，压缩后测量sizeof只有一个字节，这就是字节位域的压缩（a占2个，b占2个，c占4个，正好8bite一个字节）。

以及不能对位域取地址。为什么呢？因为地址是相对于字节来说的，你一个位域都成二进制了，哪还有地址可言？所以一取地址就报错了。

 1 struct op
 2 {
 3     unsigned char a : 2;
 4     unsigned char b : 2;
 5     unsigned char c : 4;//这些总共就一个字节，8bite内容
 6 };
 7 void test10()
 8 {
 9     op sd;
10     sd.a = 5;//0101,但是只有后两个二进制,从右往左读取，只读取到01。
11     cout << (int)(sd.a) << endl;//结果是1，乐了
12
13 }

另起一个存储单元：来一点小小的位操作震撼

无意义位段：我占了，但是我不给你用

运用案例：

九 共用体union

共用体和结构体的区别：

结构体的每一个成员都分配单独的空间；而共用体的所有成员都在同一空间内，对某一成员操作就是对整个空间操作。

 1 union gyt
 2 {
 3     int a;
 4     int b;
 5     int c;
 6 };
 7 void test11()
 8 {
 9     gyt cc;
10     cc.a = 10;
11     cc.b = 20;
12     cc.c = 30;
13     cout << cc.a + cc.b + cc.c << endl;//结果是30+30+30=90,对我们的认知来说应该是10+20+30才对。
14 }

个人理解：共用体之所以是可以一起操作是因为他们的空间是彼此覆盖的，大的数据类型覆盖了小的数据空间（相当于他们的所占空间叠在一起了）那么大改小好理解，小改大是什么原因呢？我的推测是因为小的在大的空间里面，如果小的改了大的不改，那么就会造成读取大空间的数据变量时发现里面牛头不对马嘴的情况，所以大的也一起改变了。

十 枚举enum

1 enum pocker_color {heitao,hongtao,fangkuai,meihua};
2 void test12()
3 {
4     pocker_color op = meihua;
5     cout << op << endl;//结果是0，枚举的数据开头都是从0开始排序的。
6     //如果需要修改枚举值，应该去把pocker_color的里面的值去重新用“=”来关联起来
7     //enum pocker_color {heitao=10,hongtao,fangkuai,meihua}这种
8 }

Tips：

1.指针变量只有8B，所以它只存地址，而正因为如此，内容物都存放在文字常量区（无法直接操作，只能读不能写），所以我们要在堆区申请一个new的空间，将内容放进去以便于操作。