2

我正在解析一个基于文本的文件以从中读取变量。文件中变量的存在很重要，所以我决定编写一个模板类，它将保存变量的值 ( Value) 及其存在标志 ( Exists)。

template<class Type>
class MyVariable
{
    public:
        Type    Value;
        bool    Exists;
        MyVariable()
            : Exists(false), Value(Type())
        {
        }
        MyVariable(const Type & Value)
            : Exists(true), Value(Value)
        {
        }
        MyVariable(const Type && Value)
            : Exists(true), Value(std::move(Value))
        {
        }
        MyVariable(const Type & Value, bool Existance)
            : Exists(Existance), Value(Value)
        {
        }
        MyVariable(const Type && Value, bool Existance)
            : Exists(Existance), Value(std::move(Value))
        {
        }
        size_t size() const
        {
            return Value.size();
        }
        const MyVariable & operator=(const MyVariable &  Another)
        {
            Value   = Another.Value;
            Exists  = true;
        }
        const MyVariable & operator=(const MyVariable && Another)
        {
            Value   = std::move(Another.Value);
            Exists  = true;
        }
        const Type & operator[](size_t Index) const
        {
            return Value[Index];
        }
              Type & operator[](size_t Index)
        {
            return Value[Index];
        }
        operator const Type & () const
        {
            Value;
        }
        operator Type &()
        {
            Value;
        }
};

存储的变量类型偶尔会是std::vector，所以我重载了下标运算符operator[]来直接访问向量的元素。这样我就可以将ValueandExists成员设为私有。

我在代码中像这样使用这个类：

const MyVariable<std::vector<int>> AVector({11, 22, 33, 44 ,55});
for (size_t i=0; i<AVector.size(); i++)
{
    std::wcout << L"Vector element #" << i << L" --> " << AVector.Value[i]  << std::endl;   // Works okay.
    std::wcout << L"Vector element #" << i << L" --> " << AVector[i]        << std::endl;   // Gives error.
}

我收到以下错误消息：

错误 C2679 二进制'<<'：未找到采用右侧操作数类型的运算符'const std::vector<int,std::allocator<_Ty>>'（或没有可接受的转换）

我在这里做错了什么？

4

4 回答 4

4 
const Type & operator[](size_t Index) const
{
    return Value[Index];
}

Type & operator[](size_t Index)
{
    return Value[Index];
}

那些返回类型是错误的；您正在返回包含的类型，而不是容器类型。您可以decltype为此使用：

auto operator[](size_t Index) const -> decltype(Value[Index]) 
{
    return Value[Index];
}

auto operator[](size_t Index) -> decltype(Value[Index]) 
{
    return Value[Index];
}
于 2015-12-01T09:15:48.483 回答
3

你返回错误的类型。

对于const Type & operator[](size_t Index) const, Typeis std::vector<int>，这意味着您正在尝试返回 a vector，而不是vector.

尝试将返回值的类型改为typename Type::value_type，如

const typename Type::value_type& operator[](size_t Index) const
于 2015-12-01T09:16:38.440 回答
2

您的运算符重载已声明

const Type & operator[](size_t Index) const

但是 AVector 被声明为

const MyVariable<std::vector<int>>

因此Type，在您的情况下是 std::vector，并且没有 << 运算符重载接受 cout 的 std::vector。

于 2015-12-01T09:16:59.797 回答
0

TartanLlama和Songyuanyao的答案只有在包含的变量类型（即；ValueType）为时才是正确的std::vector。如果我们尝试存储基本数据类型（例如；int或float），编译器 (MSVC14) 会给出以下错误，因为内部不会有任何隐式下标运算符operator[]或value_type成员类型定义。

'InputFileVariable<bool,std::string>::value_type': is not a type name, static, or enumerator  
'InputFileVariable<int,std::string>::value_type': is not a type name, static, or enumerator  
'InputFileVariable<uintmax_t,std::string>::value_type': is not a type name, static, or enumerator  
'InputFileVariable<float,std::string>::value_type': is not a type name, static, or enumerator

我通过使用函数模板找到了解决方案。我将下标运算符重写为模板，这样编译器就不会创建下标成员函数，除非它们被调用。而且因为我只在存储元素是时才调用它们std::vector，所以它不会对基本类型造成任何问题。

我的最终工作代码如下。

#include <vector>
#include <string>

template<class ValueType, class KeyType = std::string>
class InputFileVariable
{
    public:
        const KeyType   Key;
        ValueType       Value;
        bool            Exists;
        InputFileVariable(KeyType && Key, ValueType && Value, bool Existance = false)
            :   Key     (std::forward<KeyType>  (Key)),
                Value   (std::forward<ValueType>(Value)),
                Exists  (Existance)
        {
        }
        size_t size() const
        {
            return Value.size();
        }
        const InputFileVariable & operator=(InputFileVariable && Another)
        {
            Key     = std::forward<InputFileVariable>(Another).Key;
            Value   = std::forward<InputFileVariable>(Another).Value;
            Exists  = true;
            return *this;
        }
        template <class ElementType = ValueType::value_type>
        const typename ElementType & operator[](size_t Index) const
        {
            return Value[Index];
        }
        template <class ElementType = ValueType::value_type>
        typename ElementType & operator[](size_t Index)
        {
            return Value[Index];
        }
        operator const ValueType & () const
        {
            return Value;
        }
        operator ValueType & ()
        {
            return Value;
        }
};

int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
{
    // Used with "std::vector":
    InputFileVariable<std::vector<int>> MyVar1("MV1", {2, 4, 6, 8}, true);
    const size_t SIZE = MyVar1.size();
    std::cout << "Size = " << SIZE << std::endl;
    int Temp = MyVar1[1];
    MyVar1[1] = MyVar1[2];  // Here we call both the const and non-const operators.
    MyVar1[2] = Temp;
    for (size_t i=0; i<SIZE; i++)
    {
        std::cout << "MyVar1[" << i << "] = " << MyVar1[i] << std::endl;
    }

    // Used with "double":
    InputFileVariable<double> MyVar2("MV2", 3.14, true);
    std::cout << std::endl << "MyVar2    = " << MyVar2 << std::endl;

    std::cout << std::endl;
    _wsystem(L"timeout /t 60 /nobreak");
    return 0;
}

输出：

Size      = 4
MyVar1[0] = 2
MyVar1[1] = 6
MyVar1[2] = 4
MyVar1[3] = 8

MyVar2    = 3.14
于 2015-12-25T15:04:08.500 回答