Question

Whew, 这是一项长期的工作。

这里我的问题。我在C++和Im超载[]运营商的舱面上翻了一番模板。我的版本既简明,也非最接近,不定的版本以提及方式返回,从而可以更改类别中的项目:

myobject[1] = myvalue;

直到我使用ean作为模板参数。这里有一个充分的例子显示错误:

#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中具有专门性,实际上不符合标准集装箱的要求。

Herb Sutter Negotiations about it more in a GOTW article:

Answer 2

<代码>vector<bool>不是真正的集装箱。你的法典实际上试图重新提及不允许的单一轨道。您的集装箱改为deque。我认为,你会采取你期望的行动。

Answer 3

“vector<bool>”;与所有其他病媒一样没有实施,也不与这些病媒一样。如果你的法典能够处理其许多特殊性,那么你就更不用说使用它了,而不是担心——这多半被认为是A Bad。某些不思考的C++给我们带来启发标准委员会成员。

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

正如其他答复指出的,在病媒加固、羊毛和大鼠的情况下,提供了优化空间分配的专门技术。

然而,如果你使用病媒:参考而不是T&,你仍然能够使你的代码有效。事实上,使用集装箱是一种良好做法:在提及由STL集装箱持有的数据时参考。

T& operator[](int idx)

......

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

当然,提交人也是参考的类型:

const T operator[](int idx) const

(删除无用额外拷贝)

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

Answer 6

之所以出现这一错误,是因为vector<bool>专门包装了在座标上和上储存的细菌值;bool>:operator[]回收某些代用法,使您能够获取价值。

我不认为解决办法是把与<条码>双轨制”;bool>:operator[]

如果您希望将<条码> 即作为基本类型加以保留,则我认为,可通过使用<条码>查询器和设计;MyBool>代替<条码>MyClass的发送<条码>。

它不妨这样做:

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

友情链接