c++ - 在两个模板类型相同的情况下如何不重载 std::map::at 成员函数？

Question

我这里有一张双向 map 。我把它设为 0。我定义了成员函数，例如 insert count size 和其他函数，当然还有一个函数 at它返回对用给定键标识的元素的映射值的引用。直到类型 A 与类型 B 不同，一切正常，但是当类型 A 与类型 B 相同时，我得到一个错误，我尝试重载此函数 at，这是正确的:(但是我的想法无法帮助我解决这个错误。也许你可以给我一个例子或者告诉我在这种情况下我能做什么:)

template <class A,class B>

class BidirectionalMap
{
public:
    void insert(A a,B b)
    {
        m1.insert(std::pair<A,B> (a,b));
        m2.insert(std::pair<B,A> (b,a));
    }
    BidirectionalMap& operator =(BidirectionalMap &a)
    {
        m1=a.m1;
        m2=a.m2;
        return *this;
    }
    A& at(const A& a)
    {
        if(m1.find(a)!=m1.end()) return m1.at(a);
        else return m2.at(a);
    }
    const B& at(const A& b) const
    {
        return m1.at(b);
    }
    const A& at(const B& a) const
    {
        return m2.at(a);
    }
    int size() const
    {
        return m1.size();
    }
    int count(const A& a) const
    {
        return m1.count(a);
    }
    int count(const B& b) const
    {
        return m2.count(b);
    }
    B& operator[](const A& a)
    {
        return m1[a];
    }
    A& operator[](const B& b)
    {
        return m2[b];
    }
private:
    std::map<A,B> m1;
    std::map<B,A> m2;
};

如果我不能在 main() 中修改这个序列怎么办？

  BidirectionalMap<int, int> f;
  f.insert(3, 18);
  f.insert(8, 2);
  f.insert(7, 5);
  f.insert(9, 1);
  const BidirectionalMap<int, int> cf = f;

  if( f.at(5) == 7 &&
      f.count(12) == 0 &&
      f.at(8) == 2)
  {
    yourMark = cf[18] + cf[9];
  }

Answer 1

实现 at在 CRTP 基类中。

template<class D, class A, class B>
struct crtp_at {
  D* self() { return static_cast<D*>(this); }
  D const* self() const { return static_cast<D const*>(this); }
  const B& at(const A& b) const {
    return self()->m1.at(b);
  }
  const A& at(const B& a) const {
    return self()->m2.at(a);
  }
  B& at(const A& b) {
    return self()->m1.at(b);
  }
  A& at(const B& a) {
    return self()->m2.at(a);
  }
};
template<class D, class A>
struct crtp_at<D,A,A> {
  D* self() { return static_cast<D*>(this); }
  D const* self() const { return static_cast<D const*>(this); }
  A& at(const A& a) {
    if(self()->m1.find(a)!=self()->m1.end()) return self()->m1.at(a);
    else return self()->m2.at(a);
  }
  A const& at(const A& a) const {
    if(self()->m1.find(a)!=self()->m1.end()) return self()->m1.at(a);
    else return self()->m2.at(a);
  }
};

然后你的类(class)使用上面的像:

template <class A,class B>
class BidirectionalMap:public crtp_at< BiDirectionalMap<A,B>, A, B >
{
  // rest of your code
};

然而，我建议实际上阻止 at在这种情况下，以及不清楚您要走哪条路的任何其他方法。

对于像 short <-> double 这样的情况，您的代码中应该有明确的方法。无论如何。