重載[]運算符在C++模板類與const/nonconst版本

Question

哎，這是一個長的標題。

這是我的問題。我有一個C++的模板類，並且我重載了[]運算符。我都一個const和非const版本，與非const版本通過引用返回，以便在類物品可以改變這樣：直到我用一個布爾值作爲

myobject[1] = myvalue; 

這一切工作模板參數。下面是顯示錯誤一個完整的例子：

#include <string> 
#include <vector> 
using namespace std; 

template <class T> 
class MyClass 
{ 
    private: 
     vector<T> _items; 

    public: 

     void add(T item) 
     { 
      _items.push_back(item); 
     } 

     const T operator[](int idx) const 
     { 
      return _items[idx]; 
     } 

     T& operator[](int idx) 
     { 
      return _items[idx]; 
     } 

}; 


int main(int argc, char** argv) 
{ 
    MyClass<string> Test1;  // Works 
    Test1.add("hi"); 
    Test1.add("how are"); 
    Test1[1] = "you?"; 


    MyClass<int> Test2;   // Also works 
    Test2.add(1); 
    Test2.add(2); 
    Test2[1] = 3; 


    MyClass<bool> Test3;  // Works up until... 
    Test3.add(true); 
    Test3.add(true); 
    Test3[1] = false;   // ...this point. :(

    return 0; 
} 

錯誤是編譯器錯誤和消息是：

error: invalid initialization of non-const reference of type ‘bool&’ from a temporary of type ‘std::_Bit_reference’ 

我讀的時候，發現STL使用了一些臨時數據類型，但我不明白爲什麼它除了布爾之外的其他所有功能。

任何幫助，將不勝感激。

Answer 1

因爲vector<bool>專門從事STL，實際上並不符合標準容器的要求。一個GOTW文章中關於它的

香草薩特會談：http://www.gotw.ca/gotw/050.htm

Answer 2

A vector<bool>沒有像所有其他向量一樣實施，也不像其他向量那樣工作。你最好不要使用它，也不要擔心你的代碼不能處理它的許多特性 - 它通常被認爲是一件壞事，由一些不知情的C++標準委員會成員強加給我們。

Answer 3

一個vector<bool>是不是一個真正的容器。您的代碼正在有效地嘗試將引用返回到單個位，這是不允許的。如果您將容器更改爲deque，我相信您會得到您期望的行爲。

Answer 4

你的班級的一些單調變化應該修復它。

template <class T> 
class MyClass 
{ 
    private: 
     vector<T> _items; 

    public: 

     // This works better if you pass by const reference. 
     // This allows the compiler to form temorary objects and pass them to the method. 
     void add(T const& item) 
     { 
      _items.push_back(item); 
     } 

     // For the const version of operator[] you were returning by value. 
     // Normally I would have returned by const ref. 

     // In normal situations the result of operator[] is T& or T const& 
     // But in the case of vector<bool> it is special 
     // (because apparently we want to pack a bool vector) 

     // But technically the return type from vector is `reference` (not T&) 
     // so it you use that it should compensate for the odd behavior of vector<bool> 
     // Of course const version is `const_reference` 

     typename vector<T>::const_reference operator[](int idx) const 
     { 
      return _items[idx]; 
     } 

     typename vector<T>::reference operator[](int idx) 
     { 
      return _items[idx]; 
     } 
}; 

Answer 5

作爲其他的答案指出，一個專門被提供在載體<布爾>的情況下，以優化空間分配。

但是，如果您使用vector :: reference而不是T &，仍然可以使您的代碼有效。事實上，在引用由STL容器持有的數據時，使用container :: reference是一個好習慣。

T& operator[](int idx) 

變得

typename vector<T>::reference operator[](int idx) 

當然療法中也是常量引用一個typedef：

const T operator[](int idx) const 

和這一個變爲（除去無用額外副本）

typename vector<T>::const_reference operator[](int idx) const 

Answer 6

錯誤的原因是vector<bool>專門用於打包存儲在其中的布爾值，並且vector<bool>::operator[]返回某種可讓您訪問該值的代理。

我不認爲一種解決方案將返回與vector<bool>::operator[]相同的類型，因爲那樣你就會將遺憾的特殊行爲複製到您的容器。

如果你想使用vector爲基礎類型留着，我相信布爾問題可以通過使用vector<MyBool>，而不是當MyClass進行實例化bool進行修補。

這可能是這樣的：

#include <string> 
#include <vector> 
using namespace std; 

namespace detail 
{ 
    struct FixForBool 
    { 
     bool value; 
     FixForBool(bool b): value(b) {} 
     operator bool&() { return value; } 
     operator const bool&() const { return value; } 
    }; 

    template <class T> 
    struct FixForValueTypeSelection 
    { 
     typedef T type; 
    }; 

    template <> 
    struct FixForValueTypeSelection<bool> 
    { 
     typedef FixForBool type; 
    }; 

} 

template <class T> 
class MyClass 
{ 
    private: 
     vector<typename detail::FixForValueTypeSelection<T>::type> _items; 

    public: 

     void add(T item) 
     { 
      _items.push_back(item); 
     } 

     const T operator[](int idx) const 
     { 
      return _items[idx]; 
     } 

     T& operator[](int idx) 
     { 
      return _items[idx]; 
     } 

}; 


int main(int argc, char** argv) 
{ 
    MyClass<string> Test1;  // Works 
    Test1.add("hi"); 
    Test1.add("how are"); 
    Test1[1] = "you?"; 


    MyClass<int> Test2;   // Also works 
    Test2.add(1); 
    Test2.add(2); 
    Test2[1] = 3; 


    MyClass<bool> Test3;  // Works up until... 
    Test3.add(true); 
    Test3.add(true); 
    Test3[1] = false;   // ...this point. :(

    return 0; 
}