如何比较标准::地图中的所有项目?

您可以将std::all_of与 lambda 一起使用。 那看起来像

bool allUniform = std::all_of(std::next(myMap.begin()), 
myMap.end(), 
[&myMap](const auto& pair)
{ return myMap.begin()->second.isUniform(pair.second); });

这从[1, N)开始，并调用isUniform反对每个元素反对第一个元素。all_of也短循环，所以一旦你有一个不均匀的结果，它就会结束。

isUniform(( 是可传递的吗？也就是说，它是否遵循任何 3 个 MyData 对象的此规则：

isUniform(A, B) && isUniform(B, C) == isUniform(A, C)

如果是这样，那么您只需要 O(n( 比较。这是我的测试代码：

#include <iostream>
#include <map>
using namespace std;
class MyData {
public:
int value;
MyData(int _value) : value(_value) {}
bool isUniform(const MyData &obj) const { return value == obj.value; }
static void checkMap(map<int, MyData> myMap) {
bool allUniform = true;
MyData * firstItem = nullptr;
for (auto it = myMap.begin(); allUniform && it != myMap.end(); ++it) {
if (firstItem == nullptr) {
firstItem = &it->second;
}
else {
allUniform = firstItem->isUniform(it->second);
}
}
cout << "All Uniform: " << (allUniform ? "Yes" : "No") << endl;
}
};
int main(int, char **) {
map<int, MyData> map1;
map<int, MyData> map2;
MyData a1(1);
MyData b1(1);
MyData b2(2);
MyData c1(1);
// Should be uniform
map1.insert(std::pair<int, MyData>(1, a1));
map1.insert(std::pair<int, MyData>(2, b1));
map1.insert(std::pair<int, MyData>(3, c1));
MyData::checkMap(map1);
// Should not be uniform
map2.insert(std::pair<int, MyData>(1, a1));
map2.insert(std::pair<int, MyData>(2, b2));
map2.insert(std::pair<int, MyData>(3, c1));
MyData::checkMap(map2);
return 0;
}

使用此输出：

$ g++ -std=c++0x Foo.cpp -o Foo && Foo
All Uniform: Yes
All Uniform: No

for(item_1, item_2 : myMap) // how to implement this?

但是，如果它们彼此相等(假设isUniform传递和对称(，那就等于说它们都等于第一个元素。因此，您可以将每个元素与第一个元素进行比较。

天真地，我们得到：

bool allUniform(std::map<int, MyData> const &m)
{
if (m.empty()) return true; // or whatever makes sense for you
auto first = m.begin();
for (auto current = m.begin(); ++current != m.end(); )
{
if (!first->second.isUniform(current->second))
{
return false;
}
}
return true;
}

如果您不介意将第一个元素与自身进行比较，则可以简化此操作，因为实际上大多数复杂性只是避免这种情况。

使用下面std::adjacent_find或另一个答案中的std::all_of解决方案可能会更好。

bool allUniform(std::map<int, MyData> const &m)
{
auto first_non_uniform =
std::adjacent_find(
m.begin(), m.end(),
[](auto left, auto right)
{
return !(left->second.isUniform(right->second));
}
);
return first_non_uniform == m.end();
}

您可以使用标准算法std::adjacent_find。

例如

#include <iostream>
#include <iomanip>
#include <map>
#include <iterator>
#include<algorithm>
class MyData
{
public:
MyData( bool ban, int speed ) : ban( ban ), speed( speed )
{
}
bool isUniform(const MyData& other) const
{
return this->speed == other.speed && this->ban == other.ban;
}
private:
bool ban;
int  speed;
};

int main() 
{
std::map<int, MyData> myMap =
{
{ 1, { true, 100 } }, { 2, { true, 100 } }, { 3, { true, 100 } }    
};
auto it = std::adjacent_find( std::begin( myMap ), std::end( myMap ),
[]( const auto &p1, const auto &p2 ) 
{
return not p1.second.isUniform( p2.second );
} );
bool allUniform = it == std::end( myMap );
std::cout << std::boolalpha << allUniform << 'n';
return 0;
}

程序输出为

true

将集合中的所有元素与第一个元素进行比较：

template<class M, class F>
bool allEqual( M const& m, F&& f ) {
using std::begin; using std::end;
auto b = begin(m);
auto e = end(m);
if (b == e) return true;
for (auto it = std::next(b); it != e; ++it)
if (!f( *b, *it))
return false;
return true;
}

成对比较所有元素：

template<class M, class F>
bool pairwiseCompare( M const& m, F&& f ) {
for (auto&& a:m)
for (auto&& b:m)
{
if (std::addressof(a) == std::addressof(b))
continue;
if (!f(a,b))
return false;
}
return true;
}

这不适用于像std::vector<bool>这样的伪容器;嗯，它会，但它会浪费自我比较元素。