位域操作中的 operator[] 重载？

Question

我正在一个类似 arduino 的平台上工作（RAM 非常有限），我需要使用一个位域。我需要修改一个字节中的特定位，像这样：

OneByte myByte = 0b11101111;
myByte[5] = 1;

为了实现这一点，我写了以下内容：

typedef struct {
    uint8_t bit0:1;
    uint8_t bit1:1;
    uint8_t bit2:1;
    uint8_t bit3:1;
    uint8_t bit4:1;
    uint8_t bit5:1;
    uint8_t bit6:1;
    uint8_t bit7:1;
} BitByte;

typedef union {
    BitByte asBits;
    uint8_t asByte;
} BitField;

class OneByte
{
public:

    OneByte();      // default constructor
    ~OneByte();     // delete

    // Assignment operator
    uint8_t& operator[] (const uint8_t pos  );
    uint8_t  operator[] (const uint8_t pos  ) const;

private:
    BitField oneByte;
};

并且在我放入的 .cpp 中

// I know a switch case is horrible, but don't want to think too much
// pos shoud always be between 0 and 7
uint8_t& OneByte::operator[] (const uint8_t pos  )  
{
    if (pos < ByteSize)
    {
        switch (pos)
        {
            case 0:
                return oneByte.asBits.bit0;
                break;
            case 1:
                return oneByte.asBits.bit1;
                break;
            case 2:
                return oneByte.asBits.bit2;
                break;
            case 3:
                return oneByte.asBits.bit3;
                break;
            case 4:
                return oneByte.asBits.bit4;
                break;
            case 5:
                return oneByte.asBits.bit5;
                break;
            case 6:
                return oneByte.asBits.bit6;
                break;
            case 7:
                return oneByte.asBits.bit7;
                break;
        }
    }
    // If goes here, do some error handling
}

uint8_t operator[] (const uint8_t pos ) const; 工作正常，但问题出在

uint8_t& operator[] (const uint8_t pos  );

编译失败并出现错误：

error: cannot bind bitfield ‘((OneByte*)this)->OneByte::oneByte.BitField::asBits.BitByte::bit0’ to ‘uint8_t& {aka unsigned char&}’

我真的不知道在这种情况下该怎么做...也许再制作一个 class 来包装这个，这样我就不会使用 operator[] 重载？

Answer 1

来自[class.bit]：

A non-const reference shall not be bound to a bit-field (8.5.3).

所以您根本无法将 uint8_t& 绑定到您的任何位。您应该考虑使用 std::bitset, which solves this problem by using proxy objects (std::bitset::reference)。

Answer 2

如前所述，您不能将位域绑定到非常量引用。由于您的目标是 Arduino，因此使用 std::bitset 可能不是一个可行的选择，具体取决于您需要对功能或数据访问的控制程度。

不过有几件事我想说明一下。首先，我不建议为此使用 C++ 位域。如果您需要对这些位进行命名访问，它们会很好，但在这种情况下，我认为有更多可维护的方法来完成您想要的。其次，从索引运算符返回 uint8_t 或对其中一个的引用似乎很愚蠢，尤其是因为您实际上是在使用布尔值。

由于您使用的是单独的位，因此您需要使用代理对象来设置和检索单独的位，而不影响位域中的所有值。通过为 bool 类型提供转换运算符和赋值运算符，您可以提供对位值的无缝访问。像下面这样的东西应该适合你。

#include <iostream>
#include <cstdint>
#include <string>

class Bits
{
    typedef std::uint8_t value_type;

    value_type   bits;

    struct Twiddler
    {
        Twiddler(value_type& value, size_t bitIndex)
            : value(value), mask(1 << bitIndex)
        {}

        Twiddler& operator=(const Twiddler&) = delete;
        Twiddler& operator=(bool bit)
        {
            value = value & ~mask | static_cast<value_type>(bit ? mask : 0);
            return *this;
        }

        operator bool() { return (value & mask) != 0; }

    private:

        value_type& value;
        value_type mask;
    };

    struct ConstTwiddler
    {
        ConstTwiddler(const value_type& value, size_t bitIndex)
            : value(value), mask(1 << bitIndex)
        {}
        ConstTwiddler& operator=(const ConstTwiddler&) = delete;
        operator bool() { return (value & mask) != 0; }

    private:

        const value_type& value;
        value_type mask;
    };

public:

    Bits() : bits() {}
    Bits(value_type bits) : bits(bits) {}

    size_t size() const { return sizeof(bits) * 8; }

    Twiddler operator[](size_t index)
    {
        if (index >= size())
        {
            throw std::out_of_range("Invalid bit index");
        }
        return Twiddler(bits, index);
    }

    const ConstTwiddler operator[](size_t index) const
    {
        if (index >= size())
        {
            throw std::out_of_range("Invalid bit index");
        }
        return ConstTwiddler(bits, index);
    }
};

位域操作中的 operator[] 重载？

operator[] overload in bit-field manipulation?

c++

operator-overloading

bit-fields