使用 `for(auto& e : cont)` 是否安全？ vector<bool> 有什么问题？

Question

我发现有时使用for (auto& e : cont) 代替普通的for (auto e : cont)（其中cont 是某个容器，例如std::vector）。到目前为止，我已经找到了两个原因：

1. 引用应该避免复制对象（更快的执行）
2. 某些课程可能禁止复制（例如std::thread）

经过几次测试，我可以看到：

1. for (auto& e : cont) 适用于除 std::vector<bool> 之外的任何 std::vector<T>
2. for (cont::reference e : cont) 适用于任何std::vector<T> 包括std::vector<bool>（这里明显的问题是：
   我应该使用它而不是for (auto& e : cont) ?
3. std::vector<bool> 不被认为是真正的容器，许多人认为它应该重命名（实现很好且有用，但应该有不同的名称，如 bitset 或 bitfield 或 dynamic_bitset）
4. std::vector<bool> 可以以 for (auto& e : cont) 也可以工作的方式实现（请参阅下面的我的尝试）

这是我用于测试的代码：
（诀窍是使用reference& iterator::operator * () { return *this; }）

#include <vector>
#include <iostream>
#include <typeinfo>
using namespace std;

#define USE_STD_VECT_BOOL 0

#if USE_STD_VECT_BOOL
typedef vector<bool> BITS;
#else
typedef class bvect {
    unsigned data; // we could use vector<unsigned> but this is just an examle
    unsigned size;
public:
    bvect(): data(0), size(0) {}
    void push_back(bool value) {
        if(value) data |= (1u<<size);
        size++; }
    class reference {
        friend class bvect;
    protected:
        unsigned& data;
        unsigned  flag;
        reference(unsigned& data, unsigned flag)
        : data(data), flag(flag) {}
    public:
        operator bool() const {
            return data & flag; }
        reference& operator = (bool value) {
            if(value) data |= flag;
            else data &= ~flag;
            return *this; }
    };
    class iterator: protected reference  {
        friend class bvect;
        iterator(unsigned& data, unsigned flag)
        : reference(data, flag) {}
    public:
        typedef bool value_type;
        typedef bvect::reference reference;
        typedef input_iterator_tag iterator_category;
    //  HERE IS THE TRICK:
        reference& operator * () {
            return *this; }
        iterator& operator ++ () {
            flag <<= 1;
            return *this; }
        iterator operator ++ (int) {
            iterator tmp(*this);
            operator ++ ();
            return tmp; }
        bool operator == (const iterator& rhs) {
            return flag == rhs.flag; }
        bool operator != (const iterator& rhs) {
            return flag != rhs.flag; }
    };
    iterator begin() {
        return iterator(data, 1); }
    iterator end() {
        return iterator(data, 1<<size); }
} BITS;
#endif

int main() {
    BITS bits;
    bits.push_back(0);
    bits.push_back(1);
#if !USE_STD_VECT_BOOL
//  won't compile for vector<bool>
    for(auto& a : bits)
        cout << typeid(a).name()
          << " = " << (int)(bool)a
          << endl;
#endif
//  std::_Bit_Reference
    for(BITS::reference a : bits)
        cout << typeid(a).name()
          << " = " << (int)(bool)a
          << endl;
//  few more tests
    for(auto a : bits)
        cout << (int)(bool)a;
    for(bool a : bits)
        cout << (int)(bool)a;
    cout << endl;
}

问题：

1. 我应该使用for (cont::reference e : cont)而不是for (auto& e : cont)吗？
2. 这个技巧有什么问题？可以增强它以适应任何用例吗？
   编辑：我在这里指的是bvect::reference& bvect::iterator::operator * () { return *this; }。
3. 可以/应该更改 STL 吗？ （参考vector<bool>）

反馈：答案和评论：

1. 使用for (auto&& e : cont)（用于写入）或for (const auto& e : cont)（用于读取/枚举）似乎适用于所有情况。 （感谢 dyp 和 Praetorian）
2. 使用typename iterator_traits<decltype(begin(cont))>::reference 似乎对数组也有效（cont=boo[2]）。 （是的，它很丑陋，但我认为可以使用一些模板别名来缩短它。我想不出需要这样做的反例，所以，目前，这不是解决方案。auto&& 是）
3. 标准规定iterator::operator * () 必须返回iterator::reference（不是iterator::reference&），但仍然不知道为什么。

最终判决：

auto it = bits.begin();
auto&& e = *it; cout << (bool)e;
it++; cout << (bool)e;
cout << endl;

输出：

10

这绝对是坏事。我们应该坚持标准（iterator::operator * () 必须返回iterator::reference）。 谢谢你:)

Answer 1

vector<bool> 是vector 类模板的特化，它将布尔值存储在位域中以进行空间优化。由于不能返回对位域的引用，vector<bool>::reference 是一个类类型，一个代表单个bool 的代理。 vector<bool>::operator[] 按值返回这个代理类实例；这同样适用于取消引用 vector<bool>::iterator。

vector<bool> cont;
for (auto& e : cont) { ... }

在这里，您尝试将左值引用绑定到右值，这是不允许的。

我应该使用for (cont::reference e : cont)而不是for (auto& e : cont)吗？
诀窍有什么问题？可以增强它以适应任何用例吗？

基于范围的 for 的好处是它也适用于纯 C 数组。使用cont::reference 将失败，以及任何没有名为reference 的成员类型的可迭代类型。如果您想对循环内的容器元素进行只读访问，则应使用for(auto const& e : cont)，如果您想修改元素，则应使用for(auto&& e : cont)。

在后一种情况下，auto&& e 是一个通用引用，可以绑定到左值和右值，所以它也适用于vector<bool> 的情况。

Answer 2

对于空间优化vector<bool> 使用仅存储一位布尔值（而不是像bool 那样的一个字节）。由于operator[] 之类的东西不起作用，您无法以字节为单位获取地址。在您的情况下，您不能在此向量中逐位迭代。你最好使用set<bool>。关于vector<bool>是否应该在STL中有很多讨论。