枚举作为函数参数传入非法值仍正常工作的原因问询

我实现了一个PCB上两颗MCU通信的简易SPI方案，用于将16位值从主设备传输到从设备的虚拟寄存器，帧长为64位。
通信帧结构如下：

• bit0：读写标识（0=读；1=写）
• bit1~bit15：寄存器地址
• bit16~bit31：固定为0xFFFF，为从设备预留数据准备时间
• bit32~bit47：寄存器值
• bit48~bit63：CRC

通信本身运行正常，但提取寄存器地址时犯了错误：取传输的前2个字节转换为uint16_t，代码如下：

register_address = (uint16_t)(((byte0) & 0xFF) << 8 | ((byte1) & 0xFF));

这个地址会传入仅接受virtual_register_address_t枚举有效值的函数，枚举定义：

typedef enum virtual_register_address_t
{
// 可读可写
    REGISTER_ONE_ADD = 0,
    REGISTER_TWO_ADD,
    REGISTER_THREE_ADD,
// 只读
    ERROR_REGISTER_ADD
}virtual_register_address_t;

对应的寄存器读写函数：

uint16_t get_virtual_register(virtual_register_address_t address)
{
    uint16_t value = 0;
    switch(address)
    {
        case(REGISTER_ONE_ADD):
            value = virtual_register.registerOne;
            break;
        case(REGISTER_TWO_ADD):
            value = virtual_register.registerTwo;
            break;
        case(REGISTER_THREE_ADD):
            value = virtual_register.registerThree;
            break;
        case(ERROR_REGISTER_ADD):
            value = virtual_register.errorRegister;
            break;
        default:
            value = 0xFF;
            break;
    }
    return value;
}

void set_virtual_register(virtual_register_address_t address, uint16_t data)
{
        switch(address)
    {
        case(REGISTER_ONE_ADD):
            virtual_register.registerOne = data;
            break;
        case(REGISTER_TWO_ADD):
            virtual_register.registerTwo = data;
            break;
        case(REGISTER_THREE_ADD):
            virtual_register.registerThree = data;
            break;
        case(ERROR_REGISTER_ADD):
            break;
        default:
            break;
        
    }
}

问题在于：我提取的是帧的bit0_15而非bit115，写操作时（bit0=1）提取的地址应≥32768，但枚举有效值最大仅为3。然而代码却能正常运行：传入枚举外的参数时，函数可接受，switch不会进入default分支，还能可靠修改、返回寄存器值。

之后我修改了地址提取代码：

register_address = (uint16_t)(((byte0) & 0x7F) << 8 | ((byte1) & 0xFF));

代码依然正常工作。

按我的理解，传入非switch case值时set_virtual_register应无操作，但实际却能正确设置值。想问：枚举作为函数参数时都会出现这种情况吗？这种不符合预期的运行是如何发生的？

补充调用代码：

void spi_serialize(spi_handle_t* handle, virtual_register_address_t address, SPI_State read_or_write)
{
        uint16_t crc = 0;
        uint16_t data = 0;
        switch(read_or_write)
        {
            case(READ):
                data = get_virtual_register(address);
                handle->dataTx[4] = (uint8_t)((data >> 8) & 0xff); 
                handle->dataTx[5] = (uint8_t)(data & 0xff);
                break;
            case(WRITE):
                handle->dataTx[4] = (0xFF); 
                handle->dataTx[5] = (0xFF);
                break;
            default:
                handle->dataTx[4] = (0xAA); 
                handle->dataTx[5] = (0xBB);
                break;  
        }
        
        // CRC计算
        crc = calculateCRC(handle->dataTxBase, SPI_FRAMESIZE-2);
        handle->dataTx[SPI_FRAMESIZE-2] = ((crc >> 8) & 0XFF);
        handle->dataTx[SPI_FRAMESIZE-1] = (crc & 0xFF);
}

void spi_deserialize(spi_handle_t* handle)
{
    uint16_t register_address = 0;
    uint16_t data = 0;
    register_address = (uint16_t)(((handle->dataRx[0]) & 0xFF) << 8 | ((handle->dataRx[1]) & 0xFF)); 
    data = (uint16_t)(((handle->dataRx[4]) & 0xFF) << 8 | ((handle->dataRx[5]) & 0xFF));
    set_virtual_register(register_address, data);   
}

1. C语言中枚举的本质 #

在C语言里，枚举类型本质是整数类型，编译器默认将其当作int（或能容纳所有枚举值的最小整数类型）处理。枚举只是给一组整数起了别名，并没有限制变量/参数只能取枚举定义的值——你可以给枚举类型的变量赋值任何整数，编译器不会报错（除非开启严格类型检查警告）。

2. 不符合预期运行的核心原因 #

你遇到的情况本质是对SPI帧的字节与bit位对应关系理解错误：
通常SPI采用MSB（最高位）优先传输，64位帧的字节顺序为：byte0对应bit63_{56（帧最高8位），byte1对应bit55}48，……，byte7对应bit7_{0（帧最低8位）。而你的帧结构中，bit0（读写位）是帧的最低位，对应byte7的bit0；bit1}15（地址）对应byte7的bit1_{7和byte6的bit0}7。

但你提取地址时取了byte0和byte1，这实际上是帧的最高16位（即CRC字段）。测试时CRC值恰好等于枚举定义的寄存器地址（0、1、2、3），所以switch能匹配对应的case，代码误打误撞正常运行。

修改地址提取代码后，要么是巧合修正了字节顺序问题，要么是新提取的字段数值仍匹配枚举常量，因此代码依然正常工作。

3. 枚举作为参数的通用情况 #

在C语言中，枚举作为函数参数时确实允许传入任意整数值：

• 如果传入值与某个case的枚举常量数值相等，switch会匹配该case；
• 如果传入值与所有case都不匹配，才会进入default分支。

你的情况属于特殊巧合，而非枚举参数的普遍异常行为。

内容的提问来源于stack exchange，提问作者Archy