I am not sure what exactly you are looking for, so let me first give complete equality and then key equality. Maybe the latter fits your needs already.
Complete Equality
(While standard equivalence can be tested using std::map
's own comparison operators, the following can be used as a base for a comparison on a per-value basis.)
Complete equality can be tested using std::equal
and std::operator==
for std::pair
s:
#include <utility>
#include <algorithm>
#include <string>
#include <iostream>
#include <map>
template <typename Map>
bool map_compare (Map const &lhs, Map const &rhs) {
// No predicate needed because there is operator== for pairs already.
return lhs.size() == rhs.size()
&& std::equal(lhs.begin(), lhs.end(),
rhs.begin());
}
int main () {
using namespace std;
map<string,string> a, b;
a["Foo"] = "0";
a["Bar"] = "1";
a["Frob"] = "2";
b["Foo"] = "0";
b["Bar"] = "1";
b["Frob"] = "2";
cout << "a == b? " << map_compare (a,b) << " (should be 1)
";
b["Foo"] = "1";
cout << "a == b? " << map_compare (a,b) << " (should be 0)
";
map<string,string> c;
cout << "a == c? " << map_compare (a,c) << " (should be 0)
";
}
Key Equality
C++2003
Based on the above code, we can add a predicate to the std::equal
call:
struct Pair_First_Equal {
template <typename Pair>
bool operator() (Pair const &lhs, Pair const &rhs) const {
return lhs.first == rhs.first;
}
};
template <typename Map>
bool key_compare (Map const &lhs, Map const &rhs) {
return lhs.size() == rhs.size()
&& std::equal(lhs.begin(), lhs.end(),
rhs.begin(),
Pair_First_Equal()); // predicate instance
}
int main () {
using namespace std;
map<string,string> a, b;
a["Foo"] = "0";
a["Bar"] = "1";
a["Frob"] = "2";
b["Foo"] = "0";
b["Bar"] = "1";
b["Frob"] = "2";
cout << "a == b? " << key_compare (a,b) << " (should be 1)
";
b["Foo"] = "1";
cout << "a == b? " << key_compare (a,b) << " (should be 1)
";
map<string,string> c;
cout << "a == c? " << key_compare (a,c) << " (should be 0)
";
}
C++ (C++11)
Using the new lambda expressions, you can do this:
template <typename Map>
bool key_compare (Map const &lhs, Map const &rhs) {
auto pred = [] (decltype(*lhs.begin()) a, decltype(a) b)
{ return a.first == b.first; };
return lhs.size() == rhs.size()
&& std::equal(lhs.begin(), lhs.end(), rhs.begin(), pred);
}
C++ (C++14)
added 2014-03-12
Using the new generic lambda expressions, you can do this:
template <typename Map>
bool key_compare (Map const &lhs, Map const &rhs) {
auto pred = [] (auto a, auto b)
{ return a.first == b.first; };
return lhs.size() == rhs.size()
&& std::equal(lhs.begin(), lhs.end(), rhs.begin(), pred);
}
As a style-matter, you can also inline the lambda expressions in C++11 and C++14 directly as a parameter:
bool key_compare (Map const &lhs, Map const &rhs) {
return lhs.size() == rhs.size()
&& std::equal(lhs.begin(), lhs.end(), rhs.begin(),
[] (auto a, auto b) { return a.first == b.first; });
}