C++ 模板类重载 [] 运算符

Question

关于模板参数，我想重载模板类的 [] 运算符。像这样：

template<
    typename T,
    template<typename> class Property, 
    template<typename> class Key1, 
    template<typename> class Key2>
class a_map 
{
public:
    const Property<T>& operator[](const Key1<T>& k) const
    { return _values[k.index()]; }
    const Property<T>& operator[](const Key2<T>& k) const
    { return _values[k.index()]; }
protected:
    std::vector<Property<T> > _values;
};

我会这样使用这个类：

int main()
{
    a_map<float, prop, key_a, key_b> pm;
}

基本上我希望能够访问_values 向量内的元素，而不必担心Key 类型。重要的是他们有一个index() 成员。

但是我得到以下错误

错误 C2535: 'const 属性 &a_map::operator [](const Key1 &) const' : 成员函数已定义或 声明

尽管key_a 和key_b 是两个完全不同的types 类模板。

我错过了什么吗？编译器是否担心在某些情况下 Key1<T> 和 Key2<T> 可能实际上是同一类型？

编辑 这些是main中使用的类模板

template<typename T>
struct prop 
{
    T weight;
    T height;
};


template<typename T>
class key_a
{
public:
    int index() { return _i; }
private:
    int _i;
};

template<typename T>
class key_b
{
public:
    int index() { return 3; } // Always return 3

编辑 我正在使用 MVC++ 2008 编译器。

Answer 1

既然你的两个 operator[] 除了参数类型之外都是一样的，为什么不给它们模板呢？

    template <typename TT>
    const Property<T>& operator[](const TT& k) const
    {
        return _values[k.index()];
    }

Answer 2

您需要将您的index() 函数声明为const，因为在a_map 模板中您通过const 对象调用它们

template<typename T> class key_a {
public:
    int index() const // <- `const` is necessary
      { return _i; }
private:
    int _i;
};

template<typename T> class key_b {
public:
    int index() const // <- `const` is necessary
      { return 3; } 
};

但除此之外，一切都可以编译并且对我来说工作正常。

---

在 VS2010 编译器中尝试过，得到和你一样的错误。这显然是 MSVC++ 编译器中的编译器错误。模板-模板参数的处理不正确。

为了解决这个问题，我可以使用这种技术

template<
    typename T,
    template<typename> class Property, 
    template<typename> class Key1, 
    template<typename> class Key2>
class a_map 
{
public:
    const Property<T>& operator[](const typename Key1<T>::self& k) const
    { return _values[k.index()]; }
    const Property<T>& operator[](const typename Key2<T>::self& k) const
    { return _values[k.index()]; }
protected:
    std::vector<Property<T> > _values;
};

并将关键模板定义为

template<typename T> class key_a {
public:
    typedef key_a self;
    int index() const { return _i; }
private:
    int _i;
};

template<typename T> class key_b {
public:
    typedef key_b self;
    int index() const { return 3; } 
};

这很不优雅，但它可以在 MSVC++ 编译器中正常工作。

Answer 3

像这样编译...注意应该如何定义 Prop/K1/K2。

#include <vector>

template<
    typename T,
    template<typename> class Property, 
    template<typename> class Key1, 
    template<typename> class Key2>
class a_map 
{
public:
    const Property<T>& operator[](const Key1<T>& k) const
    { return _values[k.index()]; }
    const Property<T>& operator[](const Key2<T>& k) const
    { return _values[k.index()]; }
protected:
    std::vector<Property<T> > _values;
};

template <typename T> struct K1 { int index() const { return 0; } };
template <typename T> struct K2 { int index() const { return 0; } };
template <typename T> struct Prop { };

int main()
{
    a_map<float, Prop, K1, K2> m;
}