在分布式的服务器环境下，设计到大量的进程以及相同进程的不同实例，需要一种有效的进程id来做唯一标识。

对于这种数据结构的需求是：

• 尽可能简单，易读
• 省空间

对于游戏的服务器进程来说，天然分为哪个大区，哪个服，哪个进程类型，哪个实例。自然分为四个部分。C++提供了一种位域的类型，可以允许把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。

比如：

struct test
{
      int32 a : 16;
      int32 b : 16;
};

对于一个int32的类型，是4个字节。长度是32个位。
这里给a分配16位，给b分配16位，这样用4个字节就存储下了a和b

同理可以把一个进程的地址用一个64位的长整形来表示。如下所示：

#define IDC_BIT       8
#define SVR_BIT       16
#define TYPE_BIT      12
#define INDEX_BIT     28

struct SVR_ADDR
{
    union {
        struct 
        {
            uint64_t _idc   : IDC_BIT;
            uint64_t _svr   : SVR_BIT;
            uint64_t _type  : TYPE_BIT;
            uint64_t _index : INDEX_BIT;
        } _tag;
        uint64_t _num;
    };
    xxx
};

对于bit的长度，需要根据实际的需要算一下是否可以满足。

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

#define IDC_BIT       8
#define SVR_BIT       16
#define TYPE_BIT      12
#define INDEX_BIT     28

struct SVR_ADDR
{
    union {
        struct 
        {
            uint64_t _idc   : IDC_BIT;
            uint64_t _svr   : SVR_BIT;
            uint64_t _type  : TYPE_BIT;
            uint64_t _index : INDEX_BIT;
        } _tag;
        uint64_t _num;
    };

    int init(uint64_t app_id) {
        _num = app_id;
    }

    int init(const char *app_id) {
        int idc_id, world_id, type, index;
        int ret = sscanf(app_id, "%u.%u.%u.%u"
                , &idc_id, &world_id, &type, &index);
        if (ret != 4) {return -1;}

        set_idc(idc_id);
        set_svr(world_id);
        set_type(type);
        set_index(index);
    }

    void set_idc(int idc_id) {
        int v =  (idc_id & ((0x1 << IDC_BIT) - 1));
        _tag._idc = v;
    }

    void set_svr(int svr_id) {
        int v =  (svr_id & ((0x1 << SVR_BIT) - 1));
        _tag._svr = v;
    }

    void set_type(int type_id) {
        int v =  (type_id & ((0x1 << TYPE_BIT) - 1));
        _tag._type = v;
    }

    void set_index(int index) {
        int v =  (index & ((0x1 << INDEX_BIT) - 1));
        _tag._index = v;
    }

    int idc_id() const {
        return _tag._idc;
    }

    int svr_id() const {
        return _tag._svr;
    }
    
    int type_id() const {
        return _tag._type;
    }

    int index() const {
        return _tag._index;
    }

    const char *to_string() const
    {
        const int buffer_size = 32;
        static char buffer[buffer_size];
        snprintf(buffer, buffer_size, "%hhu.%hu.%hhu.%hhu", (int) _tag._idc,
                (int) _tag._svr, (int) _tag._type, (int) _tag._index);
        return buffer;
    }

    uint64_t to_number() const {return _num;}
};

int main()
{
    SVR_ADDR addr;
    addr.init("10.1.1.1");
    printf("%s %d \n", addr.to_string(), addr.to_number());

    addr.set_idc(10);
    addr.set_svr(1);
    addr.set_type(1);
    addr.set_index(1);
    printf("%s %d \n", addr.to_string(), addr.to_number());
    return 0;
}

./a.out                                                                             
10.1.1.1 16777482 
10.1.1.1 16777482