C++ 如何在C+中使用不同的比较器返回map+；？

如果我有一个具有2

std:：map

属性的类，这两个属性都具有不同的比较器，那么我如何编写一个函数来返回它们中的任何一个呢？ 例如：

类测试{
公众：
标准：：映射和获取映射（int id）{
如果（id==1）
返回图1；
其他的
返回图2；
}
私人：
std：：map_1；
std:：map_2；
};

这里编译器将失败，因为

map_2

不是

std:：map

。

---

我还尝试了

std:：map

作为返回类型，但这也不起作用。

简短回答：你不能

模板只是模板。模板的不同实例化是不同的类型。如果

map

将是您的类型，那么您可以使不同的实例化从公共基继承并以多态方式使用它们。但是，

std:：map

不是您的类型，因此您不能这样做。您可以返回一个

std:：variant

，但编写两个getter要容易得多

---

最后但并非最不重要的一点是，如果返回对私有成员的非常量引用，则实际上没有封装。您还可以公开成员，这也将消除您当前的问题。

无法编写可以直接返回的函数，因为它们具有不同的类型（没有公共基类）。但是，您可以有一个函数模板：

template<class Comp>
std::map<int, int, Comp>& get_map();

---

---

面向对象的方法可以是根本不提供getter，只对类内的映射进行操作。

作为替代方法，您可以删除比较器类型，以具有相同的映射类型：

class Test {
public:
  std::map<int, int, bool (*)(int, int)> &get_map(int id) {
      return (id == 1) ? map_1 : map_2;
  }

private:
  std::map<int, int, bool (*)(int, int)> map_1 = {+[](int lhs, int rhs) { return lhs < rhs; }};
  std::map<int, int, bool (*)(int, int)> map_2 = {+[](int lhs, int rhs) { return lhs > rhs; }};
};

类测试{
公众：
标准：：映射和获取映射（int id）{
返回（id==1）？map_1:map_2；
}
私人：
映射映射1={+[]（int-lhs，int-rhs）{返回lhsrhs；}；
};

另一个选项是使用参数编写自己的比较器：

struct Cmp {
    Cmp(bool is_less) : is_less(is_less)
    {}

    bool operator()(int lhs, int rhs) const { 
        if (is_less) {
            return lhs < rhs;
        } else {
            return lhs > rhs;
        }
    }

private:
    bool is_less;
};

class Test {
public:
  Test() :
    map_1(Cmp(true)),
    map_2(Cmp(false))
  {}

  std::map<int, int, Cmp> &get_map(int id) {
    if (id == 1)
      return map_1;
    else
      return map_2;
  }

private:
  std::map<int, int, Cmp> map_1;
  std::map<int, int, Cmp> map_2;
};

---

你不能。创建两个getter函数instead我会用

reference\u wrapper

写一个答案，但你的更好

class Test {
public:
  Test() :
    map_1(Cmp(true)),
    map_2(Cmp(false))
  {}

  std::map<int, int, Cmp> &get_map(int id) {
    if (id == 1)
      return map_1;
    else
      return map_2;
  }

private:
  std::map<int, int, Cmp> map_1;
  std::map<int, int, Cmp> map_2;
};