C++ 位字段操作中的运算符[]过载？

我正在一个类似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
}

编译失败，出现以下错误：

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

我真的不知道在这种情况下该怎么办。。。也许可以创建另一个类来包装这个类，这样我就不会使用[class.bit]中的

操作符[]

重载？

：

非常量引用不应绑定到 位字段（8.5.3）

---

因此，您无法将

uint8\t&

绑定到任何位。您应该考虑使用，使用代理对象（）来解决这个问题。p> 如前所述，不能将位字段绑定到非常量引用。由于使用

std:：bitset

瞄准Arduino可能不是一个可行的选项，这取决于您对功能或数据访问的控制程度

不过，有几件事我要注意。首先，我不推荐使用C++位字段。如果您需要对bits进行命名访问，它们是很好的，但是在这种情况下，我认为有更多可维护的方法来实现您想要的。其次，返回

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);
    }
};

#包括
#包括
#包括
类位
{
typedef std:：uint8_t value_type；
值类型位；
结构旋转器
{
旋转器（值、类型和值、大小和索引）
：值（value），掩码（1=size（））
{
抛出std：：超出范围（“无效位索引”）；
}
返回常量旋转器（位、索引）；
}
};

omap2\u sdrc\u init如何进行位操作。真的，当你写一些小的、低级的、不太公开的、但时间紧迫或内存有限的东西时，就把它写得难看些，原谅自己吧。谢谢！这正是我想要的，但似乎AVR-GCC不存在std:：位集？我想我不用代理，而是使用一个丑陋的setBit和getBit，比如@user3528438！非常感谢你！我不得不改变一些事情，但最终成功了（ishh）

#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);
    }
};