C++十六进制宏与位运算实战：状态标志的高效组合与转换

利用十六进制宏管理状态标志

在 C++ 开发中，一种流行的做法是使用二进制的每一位代表一种独立的状态。例如，001、010、100 分别代表三种不同的状态。这种设计的核心优势在于可以通过位运算优雅地组合和去除状态，相比枚举能更灵活地处理多重标志的组合。

第1步：定义十六进制宏标志

为了实现每bit代表一个状态，通常将宏定义为 $2^n$ 的形式。由于十六进制每4位二进制正好对应1位十六进制数，使用 0x001L、0x002L、0x004L 等定义非常直观：

#define TL_YAN   0x001L // 00001 盐
#define TL_TANG  0x002L // 00010 糖
#define TL_JIANGYOU 0x004L // 00100 酱油
#define TL_CU    0x008L // 01000 醋
#define TL_LAJIAO 0x010L // 01000 辣椒
typedef long LONG;

这种做法的代码相对优雅，且通过十六进制表示二进制，更容易在调试时判断某一位的值。虽然也可以使用 enum，但在实现灵活的位组合（如同时添加盐和糖）时，位运算更为直接。

第2步：使用或运算(|)组合状态

要启用多种状态，只需将它们进行按位或运算：

• 001 | 010 = 011：同时启用前两种状态。
• 001 | 010 | 100 = 111：同时启用所有三种状态。

在实际函数调用中，可以这样传入参数：

Func(TL_YAN | TL_TANG); // 需要盐和糖

第3步：使用与运算(&)判断状态

检查某个特定状态是否存在时，使用该状态对应的掩码与原值进行按位与运算。如果结果不为0，说明该位为1；如果结果为0，说明该位为0。

原理示例： - 如果原值是 001，001 & 100 = 000（无辣椒状态）。 - 如果原值是 101，001 & 101 = 001（有盐状态）。

完整判断逻辑代码如下：

// 调料
void TiaoLiao(LONG l)
{
    if(l & TL_YAN)     // 00001 & xxxx1 = 00001 (非零则为真)
        cout << "盐" << endl;
    
    if(l & TL_TANG)    // 00010 & xxx0x = 00000 (若第三位为0则全为0)
        cout << "糖" << endl;
    
    if(l & TL_JIANGYOU)
        cout << "酱油" << endl;
    
    if(l & TL_CU)
        cout << "醋" << endl;
    
    if(l & TL_LAJIAO)
        cout << "辣椒" << endl;
}

void main()
{
    cout << "你需要调料：" << endl;
    TiaoLiao(TL_LAJIAO | TL_TANG); // 传入辣椒和糖的标志
    system("pause");
}

第4步：使用与和非运算清除状态

除了获取状态，还可以修改状态。要从现有标志中去除某种状态（将该位置0），可以将该状态取反后与原值进行与运算：

BYTE c = b & ~TL_CU; // 确保醋位被清零，其他位不变

C++ 中八进制与十六进制的表达规范

理解不同进制的字面量写法是进行位操作的基础。C 和 C++ 对这三种常见进制有明确的语法规定：

1. 八进制表达

如果希望在代码中明确表示一个数是八进制，必须在前面加上数字 0。例如：int 0123; 是八进制，而 123 默认是十进制。

例外情况：转义字符。由于 C/C++ 不允许斜杠后跟纯十进制数来表示字符，因此可以使用八进制转义序列：

'\077' // ASCII值为63的'?'，用8进制表示
'

注意：八进制只能用于无符号正整数的字面量表达，负号需单独处理（如 -078 并非标准的负八进制字面量写法，编译行为依赖于具体实现，通常不建议混写）。

2. 十六进制表达

十六进制数必须以 0x 或 0X 开头。其中的 x 不区分大小写。注意 0 是数字零，而非字母 o。

int 0x15A; // 合法的十六进制

常见数据类型的进制转换实现

在实际编程（如 Qt 开发或底层通信协议解析）中，经常需要在字符串形式和整型值之间进行进制转换。以下是几种典型场景的实现：

1. Qt 环境下的转换

如果项目使用 Qt，可以直接调用内置方法：

// 十进制转十六进制字符串
int a = 63;
QString s = QString::number(a, 16);    // s == "3f"
QString t = QString::number(a, 16).toUpper(); // t == "3F"

// 字符串按指定进制解析为整数
QString str = "FF";
bool ok;
int hexVal = str.toInt(&ok, 16); // hexVal == 255, ok == true
int decVal = str.toInt(&ok, 10); // decVal == 0, ok == false (因为"FF"不是十进制)

2. C++ 原生手动转换算法

在非 Qt 环境下，或者为了更深入理解，可以实现以下转换函数：

十六进制字符串转十进制整数

WORD DEC(CString str)
{
    WORD decvalue = 0;
    int i = 0;
    for(i=0; i<str.GetLength(); i++)
    {
        // 处理小写字母 a-f
        if(str[i] >='a' && str[i] <='f')
            decvalue = decvalue * 16 + (str[i] - 'a' + 10);
        // 处理大写字母 A-F
        else if((str[i] >='A') && (str[i] <='F'))
            decvalue = decvalue * 16 + (str[i] - 'A' + 10);
        // 处理数字 0-9
        else if(str[i] >='0' && str[i] <='9')
            decvalue = decvalue * 16 + (str[i] - '0');
    }
    return decvalue;
}

二进制字符串转十进制整数

WORD BINToDEM(CString str)
{
    WORD decvalue = 0;
    int len = str.GetLength();
    for(int i=0; i<len; i++)
    {
        if(str[i]=='1')
        {
            // 从低位到高位累加，或者直接按权重计算
            // 这里演示按位置权重：第i位(从左数)对应 2^(len-1-i)
            decvalue += WORD(pow(2, (len-1-i)));
        }
    }
    return decvalue;
}

十进制整数转二进制字符串

CString DECToBIN(int idata)
{
    CString outStr = _T("");
    int iBIN[32];
    int i = 0;
    
    // 除2取余法
    while(idata)
    {
        iBIN[i] = idata % 2;
        idata = idata / 2;
        i++;
    }
    
    // 逆序输出
    for(int j=i-1; j>=0; j--)
    {
        CString tempStr;
        tempStr.Format(_T("%d"), iBIN[j]);
        outStr += tempStr;
    }
    return outStr;
}

位运算深度解析

位运算是计算机底层数据处理的核心，涉及六种运算符：

• & (与): 两数位都为1时结果为1。常用于**检查特定位**或**清零特定位**（配合~）。
• | (或): 只要有一位为1，结果即为1。常用于**置位特定标志。
• ^ (异或): 两位不同时为1，相同时为0。常用于**位翻转**（如 b ^ 0x18 翻转第3、4位，再次异或即可恢复）。
• ~ (非): 单目运算符，按位取反。常用于生成掩码。
• << (左移) / >> (右移): 向左或向右移动指定位数。常用于对齐位排列或乘以/除以2的幂。

位域 (BitField) 结构体

为了极致节省内存，可以使用位域来紧凑存储数据。例如存储日期：

struct date_struct {
    BYTE day : 5;      // 1-31，占用5位
    BYTE month : 4;    // 1-12，占用4位
    BYTE year : 14;    // 0-9999，占用14位
}; // 总共占用23位，约3个字节

编译器会自动分配内存块（如 BYTE 为8位，若超出则分配下一个 BYTE）。访问方式与普通结构体成员相同，但无法获取位域成员的地址。