C++ 如何为地图创建自己的比较器？ typedef-map-myMap；

将新对插入到

myMap

时，它将使用键

string

通过自己的字符串比较器进行比较。有可能覆盖那个比较器吗？例如，我想比较键

string

的长度，而不是字母表。或者有其他方法对映射进行排序吗？

std:：map

最多使用四个模板类型参数，第三个是比较器。例如：

typedef map<string, string> myMap;

struct cmpByStringLength{
布尔运算符（）（常数std:：string&a，常数std:：string&b）常数{
返回a.length（）

或者，您也可以将比较器传递给

---

但是请注意，当按长度进行比较时，映射中每个长度只能有一个字符串作为键。

是的，

map

上的第三个模板参数指定了比较器，它是一个二进制谓词。例如：

struct cmpByStringLength {
    bool operator()(const std::string& a, const std::string& b) const {
        return a.length() < b.length();
    }
};

// ...
std::map<std::string, std::string, cmpByStringLength> myMap;

structbyllength:public std:：binary_函数
{
布尔运算符（）（常量字符串和lhs、常量字符串和rhs）常量
{
返回lhs.length（）
struct ByLength : public std::binary_function<string, string, bool>
{
    bool operator()(const string& lhs, const string& rhs) const
    {
        return lhs.length() < rhs.length();
    }
};

int main()
{
    typedef map<string, string, ByLength> lenmap;
    lenmap mymap;

    mymap["one"] = "one";
    mymap["a"] = "a";
    mymap["fewbahr"] = "foobar";

    for( lenmap::const_iterator it = mymap.begin(), end = mymap.end(); it != end; ++it )
        cout << it->first << "\n";
}

auto comp=[]（常量字符串&a，常量字符串&b）{返回a.length（）cout将指向比较函数的指针类型指定为映射中的第三种类型，并提供指向映射构造函数的函数指针：

map映射名（pointertocomparison函数）；

下面的示例提供了一个与
映射
的比较函数，其中
向量
迭代器作为键，
int
作为值

auto comp = [](const string& a, const string& b) { return a.length() < b.length(); };
map<string, string, decltype(comp)> my_map(comp);

my_map["1"]      = "a";
my_map["three"]  = "b";
my_map["two"]    = "c";
my_map["fouuur"] = "d";

for(auto const &kv : my_map)
    cout << kv.first << endl;

#包括“headers.h”
bool int_vector_iter_comp（常量向量：：迭代器iter1，常量向量：：迭代器iter2）{
返回*iter1<*iter2；
}
int main（）{
//不提供自定义比较功能
地图默认值比较；
//提供自定义比较功能
//基本版本
地图
基本（内部向量计算）；
//使用decltype
带有_decltype（&int _vector _iter _comp）的映射；
//使用类型别名或使用
typedef bool my_谓词（常量向量：：迭代器iter1，常量向量：：迭代器iter2）；
带有类型定义的映射（&int\u vector\u iter\u comp）；
使用my_谓词_指针_type=bool（*）（常量向量：：迭代器iter1，常量向量：：迭代器iter2）；
使用（&int_vector_iter_comp）与_映射；
//测试
向量v={1,2,3}；
default_comparison.insert（对（{v.end（），0}））；
default_comparison.insert（对（{v.begin（），0}））；
default_comparison.insert（对（{v.begin（），1}））；
default_comparison.insert（对（{v.begin（）+1，1}））；
请注意，如果要包含重复的，可以使用多重映射key@GeorgFritzsche有没有可能提供一个将comparitor传递给构造函数的示例？@bpeikes:看起来没有太大区别：
std:：map myMap（cmpByStringLength（））
我对std:：map有一个问题，有些是递增顺序的，有些是递减顺序的。我不想使用std:：map和std:：map，因为这样我就不能使用按不同顺序排序的映射作为单个函数的参数，除非我将所有内容都作为模板。我发现我必须执行以下操作：typedef std:：map mymap；然后我就可以传入函数了。我尝试了以下方法，但没有成功：typedef std:：map mymap；mymap map1（std:：less）；mymap map2（std:：greater）；@GeorgFritzsche：将比较器传递给构造函数不起作用，因为构造函数参数必须是比较器类型的实例，
cmpByStringLength
不是
std:：less
的实例。对于可以在构造函数中设置任何比较器的常规映射，您需要类似
std:：map myMa的内容p（cmpByStringLength）；
为什么需要派生自
std:：binary_函数
？在c++17中删除了
std:：binary_函数
，因此此答案可能需要更新。
#include "headers.h"

bool int_vector_iter_comp(const vector<int>::iterator iter1, const vector<int>::iterator iter2) {
    return *iter1 < *iter2;
}

int main() {
    // Without providing custom comparison function
    map<vector<int>::iterator, int> default_comparison;

    // Providing custom comparison function
    // Basic version
    map<vector<int>::iterator, int,
        bool (*)(const vector<int>::iterator iter1, const vector<int>::iterator iter2)>
        basic(int_vector_iter_comp);

    // use decltype
    map<vector<int>::iterator, int, decltype(int_vector_iter_comp)*> with_decltype(&int_vector_iter_comp);

    // Use type alias or using
    typedef bool my_predicate(const vector<int>::iterator iter1, const vector<int>::iterator iter2);
    map<vector<int>::iterator, int, my_predicate*> with_typedef(&int_vector_iter_comp);

    using my_predicate_pointer_type = bool (*)(const vector<int>::iterator iter1, const vector<int>::iterator iter2);
    map<vector<int>::iterator, int, my_predicate_pointer_type> with_using(&int_vector_iter_comp);


    // Testing 
    vector<int> v = {1, 2, 3};

    default_comparison.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    default_comparison.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    default_comparison.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    default_comparison.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << default_comparison.size() << endl;
    for (auto& p : default_comparison) {
        cout << *(p.first) << ": " << p.second << endl;
    }

    basic.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    basic.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    basic.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    basic.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << basic.size() << endl;
    for (auto& p : basic) {
        cout << *(p.first) << ": " << p.second << endl;
    }

    with_decltype.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    with_decltype.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    with_decltype.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    with_decltype.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << with_decltype.size() << endl;
    for (auto& p : with_decltype) {
        cout << *(p.first) << ": " << p.second << endl;
    }

    with_typedef.insert(pair<vector<int>::iterator, int>({v.end(), 0}));
    with_typedef.insert(pair<vector<int>::iterator, int>({v.begin(), 0}));
    with_typedef.insert(pair<vector<int>::iterator, int>({v.begin(), 1}));
    with_typedef.insert(pair<vector<int>::iterator, int>({v.begin() + 1, 1}));

    cout << "size: " << with_typedef.size() << endl;
    for (auto& p : with_typedef) {
        cout << *(p.first) << ": " << p.second << endl;
    }
}