#include <iostream>
#include <map>
#include <string>
#include <string.h>
#include <functional>
using namespace std;
// Define comparator functor:
struct functor_test
{
bool operator()(string const & lhs, string const & rhs)
{
return strncmp(lhs.c_str(), rhs.c_str(), 4) < 0;
}
};
// Define comparator function:
bool function_test(string const & lhs, string const & rhs)
{
return strncmp(lhs.c_str(), rhs.c_str(), 4) < 0;
}
int main() {
// Define comparator lambda:
auto lambda_test = [](string const & lhs, string const & rhs)
{
return strncmp(lhs.c_str(), rhs.c_str(), 4) < 0;
};
// These are all valid ways to declare the key comparator :
//As a functor:
// map<string, string, functor_test> map;
//As a function using a function reference type:
// map<string, string, bool(&)(string const&, string const&)> map(function_test);
//As a function using a function pointer type:
// map<string, string, bool(*)(string const&, string const&)> map(function_test);
//As a function using a function class type wrapper:
// map<string, string, function<bool(string const&, string const&)>> map(function_test);
//As a predefined lambda:
// map<string, string, decltype(lambda_test)> map(lambda_test);
//As a predefined lambda using a function class type wrapper:
// map<string, string, function<bool(string const&, string const&)>> map(lambda_test);
//As a lambda using a function class type wrapper:
map<string, string, function<bool(string const&, string const&)>> map(
[](string const & lhs, string const & rhs)
{
return strncmp(lhs.c_str(), rhs.c_str(), 4) < 0;
});
map["test"] = "Foo";
map["blah"] = "Drei";
map["fayh"] = "Najh";
std::cout << map.find("test123")->second << endl; // Should output 'Foo'
std::cout << map.find("test_2165")->second << endl; // Should output 'Foo' as well
if (map.find("tes") == map.end())
{
cout << "Not found" << endl;
}// Key not found
std::cout << map.find("fayh_TK_Ka")->second << endl; // 'Najh'
return 0;
}
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