联合体和位域¶

位域¶

优化内存，节省内存空间

//0000 0001
struct LGCar2 {
    BOOL front: 1;//占1个位置 不是字节
    BOOL back : 2;//占2个位置
    BOOL left : 6;//占6个位置
    BOOL right: 1;//占1个位置
};

struct LGStruct1 {
    char a;//1字节
    char b;
    char c;
    char d;
}struct1;//4字节

struct LGStruct2 {
    char a : 1;//位域 :1 用1个域，占1个位
    char b : 1;
    char c : 1;
    char d : 1;
}struct2;//1字节

struct LGStruct3 {
    // a: 位域名  32:位域长度
    int a : 32;
    char b : 2;
    char c : 7;
    char d : 2;
}struct3;

struct LGTeacher1 {
    char *name;
    int age;
    double height;
}t1;

联合体union¶

共享内存，共用一块内存空间。

划一块足够大的内存空间，整块内存空间怎么使用，操作系统不会管理，程序员自己管理。

结构体里面的成员变量是共存，联合体里面的成员变量是互斥。

作用：节省内存空间。

用处：成员变量只能存在一个的时候。

//8字节
///1. 联合体必须能够容纳最大的成员变量
///2. 通过1计算出来的大小必须是其最大成员变量(基本数据类型)的整数倍
union LGTeacher2 {
    char *name;//指针 8字节
    int age;
    int height;
}t2;

union LGTeacher3 {
    char a[7]; //7
    int b; // 4
}t3; // 8

C++和C都有联合。C++的联合做了增强。

使用union 里面成员的公用存储空间，优点节省空间。

一个union里有多个成员，多个成员共用存储空间。使用union节省空间。

union U
{
private:
    int i;  //成员变量
    float f;
public:
    U(int a);   //构造函数
    U(float b);
    ~U();       //析构函数
    int read_int(); //成员函数
    float read_float();
};

U::U(int a) {i = a;}
U::U(float b) {f = b;}
U::~U() {cout << "U::~U()" << endl;}
int U::read_int() {return i;}
float U::read_float() {return f;}

void test()
{
    U X(12), Y(1.9f);
    cout << X.read_int() << endl;
    cout << Y.read_float() << endl;
}

Union 不安全，如果写成了cout << X.read_float() << endl;无法检查出来，结果是不对的。有可能错误的使用。

联合（union）
构造函数
析构函数
成员函数
访问控制
使用类封装联合

union类型不安全。要想使用安全，使用C++的类进行封装union。

class SuperVar
{
    enum//匿名枚举
    {
        character,
        integer,
        floating_point
    } varType;//varType是SuperVar的一个枚举类型的成员变量  （varType会用在print函数里，保证类型安全的）
    union//匿名的union 使用的时候可以直接使用
    {//c i f 共用存储空间
        char c;
        int i;
        float f;
    };
public:
    SuperVar(char ch);
    SuperVar(int ii);
    SuperVar(float ff);
    void print();
};

源文件

//三个构造函数
SuperVar::SuperVar(char ch)
{
    c = ch;
    varType = character;
}
SuperVar::SuperVar(int ii)
{
    i = ii;
    varType = integer;
}
SuperVar::SuperVar(float ff)
{
    f = ff;
    varType = floating_point;
}

还有一个print函数

print会自动检查保存响应的类型并输出，所以不会出错，类型安全的。

void SuperVar::print()
{
    //首先检查类型,在构造函数里已经把类型保存好了
    switch (varType) {
            //根据不同的类型进行输出
        case SuperVar::character:
            cout << "character:" << c << endl;
            break;
        case SuperVar::integer:
            cout << "integer:" << i << endl;
            break;
        case SuperVar::floating_point:
            cout << "float:" << f << endl;
            break;
        default:
            break;
    }
}

最大优点：节省存储空间，几个成员共用存储空间。

因为现在电脑内存大了，所以用union体现不出来优势。

所以用class struct多些成员存储空间是分开的，如果是union是共用的，但是现在用class struct的多。

只有在大型的数据结构中可能用到union，因为数据多，每一个节省一点点，积少成多。可以节省一点空间。