联合体与位域

在对 OC 对象创建的探究过程中，我们发现一个很有趣的实现 isa。isa 是将对象内存空间与 class 之间联结起来的桥梁，而他的实现也很精妙，在有限的存储空间(一个寄存器的存储空间，在 64 位架构为 16 个字节，在 32 位的架构为 8 个字节)里，记录了很多的内容。他的实现方式正是我们今天的主角 – 联合体与位域。

联合体

我们知道在 C 语言中结构体 struct 是一种构造类型或复杂类型，它可以包含多个类型不同的成员。还有另外一种和结构体非常类似的语法，叫做共用体，也叫联合体。

union 共用体名 {
	成员列表
}

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

结构体占用的内存大于等于所有成员占用的内存的总和（成员之间可能会存在缝隙），共用体占用的内存等于最长的成员占用的内存。共用体使用了内存覆盖技术，同一时刻只能保存一个成员的值，如果对新的成员赋值，就会把原来成员的值覆盖掉。

union Data {
    int a;
    short b;
    char c;
} data;

int main(int argc, const char * argv[]) { 
	data.a = 4;
	data.b = 8;
	data.c = 'c';
	NSLog(@"union data: %lu - %lu", sizeof(data), sizeof(union Data)); // union data: 4 - 4
}

联合体 data 中：

• a 是 int 类型，4 个字节，所占字节最多
• b 是 short 类型，2 个字节
• c 是 char 类型，1个字节

所以 data 所占内存是 4 个字节。

接下来我们来验证下联合体在计算机中是如何存储数据的：

data.c = 'g';
NSLog(@"a: %d, b: %d, c: %c", data.a, data.b, data.c);
data.b = 0x5341;
NSLog(@"a: %d, b: %d, c: %c", data.a, data.b, data.c);
data.a = 0x123a4e63;
NSLog(@"a: %d, b: %d, c: %c", data.a, data.b, data.c);

结合图中的输出，即验证了共用体的长度，也验证了共用体成员之间会相互影响，修改一个成员的值会影响其他成员。

为了更好的理解上面的输出结构，简单画了下其各个成员在内存中的分布：

在计算机中，数据多以小端模式（即从低地址开始存储，数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中）存储，上图就是以小端模式的内存分布。

位域

在理解位域之前，我们先来看一个例子：

我们有一辆坦克，他可以向前、后、左、右四个方向中其中几个方向前进。

@interface SMTank : NSObject

@property (nonatomic, assign) BOOL front;
@property (nonatomic, assign) BOOL back;
@property (nonatomic, assign) BOOL left;
@property (nonatomic, assign) BOOL right;

@end

我们可以看到 front、back、left、right各占一个字节，但其实我们只需要一个二进制就可以表现出来，也就是 0 或则 1 就可以。

这个时候，我们就可以使用位域：

// SMTankCopy.h
@interface SMTankCopy : NSObject

- (void)setFront:(BOOL)isFront;
- (BOOL)isFront;
- (void)setBack:(BOOL)isBack;
- (BOOL)isBack;
- (void)setLeft:(BOOL)isLeft;
- (BOOL)isLeft;
- (void)setRight:(BOOL)isRight;
- (BOOL)isRight;

@end

// SMTankCopy.m
#define SMDirectionFrontMask (1 << 0)
#define SMDirectionBackMask  (1 << 1)
#define SMDirectionLeftMask  (1 << 2)
#define SMDirectionRightMask (1 << 3)

@interface SMTankCopy () {
    union {
        char bits;
        struct {
            char front: 1;
            char back:  1;
            char left:  1;
            char right: 1;
        };
    } _direction;
}

@end

@implementation SMTankCopy

- (instancetype)init {
    self = [super init];
    if (self) {
        _direction.bits = 0b00000000;
    }
    return self;
}

// 这里可以有两种写法，得到的结果是一样的
- (void)setFront:(BOOL)isFront {
//    if (isFront) {
//        _direction.bits |= SMDirectionFrontMask;
//    } else {
//        _direction.bits &= ~SMDirectionFrontMask;
//    }
    
    _direction.left = isFront;
}

- (BOOL)isFront {
    return !!(_direction.bits & SMDirectionFrontMask);
}

- (void)setBack:(BOOL)isBack {
    _direction.back = isBack;
}

- (BOOL)isBack {
    return !!(_direction.back & SMDirectionBackMask);
}

- (void)setLeft:(BOOL)isLeft {
    _direction.left = isLeft;
}

- (BOOL)isLeft {
    return !!(_direction.left & SMDirectionLeftMask);
}

- (void)setRight:(BOOL)isRight {
    _direction.right = isRight;
}

- (BOOL)isRight {
    return !!(_direction.left & SMDirectionLeftMask);
}

@end

如果我们以结构体来作为存储结构的话，还可以节省内存：

struct SMTank {
    char left;
    char right;
    char front;
    char back;
} tank;

struct SMTank2 {
    union {
        char bits;
        struct {
            char front  :1;
            char back   :1;
            char left   :1;
            char right  :1;
        };
    } direction;
} tank2;

tank.left = 1;
tank.right = 1;
tank.front = 1;
tank.back = 1;
NSLog(@"tank: %lu", sizeof(tank)); // tank: 4
    
tank2.direction.left = 1;
tank2.direction.right = 1;
tank2.direction.front = 1;
tank2.direction.back = 1;
NSLog(@"tank: %lu", sizeof(tank2)); // tank: 1

因为联合体共用内存，所以 tank2 只占一个字节。

有些数据在存储时并不需要占用一个完整的字节，只需要占用一个或几个二进制位即可。基于这种的数据结构，就是位域。