Stl 检查std:：map的所有值是否相等的最简单方法

检查某些std:：map的值对于所有键是否相等的最简单方法是什么，而不需要（至少是可见的）对所有键进行迭代？可以在一次操作中完成吗？

使用并验证映射的开始迭代器和返回的结束迭代器之间的距离是否为1。

使用并验证映射的开始迭代器和返回的结束迭代器之间的距离是否为1。

此函数可能适合您的需要

template <typename Map>
bool IsUnique(const Map& i_map)
  {
  return std::count_if(i_map.cbegin(), i_map.cend(), 
      [&i_map] (typename Map::const_reference v)
      { 
      return v.second == i_map.cbegin()->second; 
      }) == i_map.size();
  }

模板
布尔是唯一的（常量映射和i_映射）
{
返回std:：count_if（i_map.cbegin（），i_map.cend（），
[&i_映射]（类型名称映射：：常量引用v）
{ 
返回v.second==i_map.cbegin（）->second；
})==i_map.size（）；
}

此功能可能适合您的需要

template <typename Map>
bool IsUnique(const Map& i_map)
  {
  return std::count_if(i_map.cbegin(), i_map.cend(), 
      [&i_map] (typename Map::const_reference v)
      { 
      return v.second == i_map.cbegin()->second; 
      }) == i_map.size();
  }

模板
布尔是唯一的（常量映射和i_映射）
{
返回std:：count_if（i_map.cbegin（），i_map.cend（），
[&i_映射]（类型名称映射：：常量引用v）
{ 
返回v.second==i_map.cbegin（）->second；
})==i_map.size（）；
}

获取第一个元素的值，然后使用自定义谓词检查其余元素。比如：

if (!mp.empty()) {
    int val = mp.begin()->second;
    result = std::all_of(std::next(mp.begin()), mp.end(), 
                         [val](typename <insert map type>::const_reference t){ return t->second == val; });
}

if（！mp.empty（））{
int val=mp.begin（）->秒；
result=std:：all_of（std:：next（mp.begin（））、mp.end（），
[val]（typename:：const_reference t）{return t->second==val；}）；
}

获取第一个元素的值，然后使用自定义谓词检查其余元素。比如：

if (!mp.empty()) {
    int val = mp.begin()->second;
    result = std::all_of(std::next(mp.begin()), mp.end(), 
                         [val](typename <insert map type>::const_reference t){ return t->second == val; });
}

if（！mp.empty（））{
int val=mp.begin（）->秒；
result=std:：all_of（std:：next（mp.begin（））、mp.end（），
[val]（typename:：const_reference t）{return t->second==val；}）；
}

您甚至可以在不使用if语句的情况下使用std:：all\u检查空映射的情况下执行此操作，如果您可以使用一个冗余比较：

template<typename Key, typename Value>
bool all_equal(std::map<Key, Value> const& map)
{
    // the lambda will only get called when the map is not empty
    // so we can safely access begin()->second
    auto const cmpWithFirst = [&](std::pair<Key,Value> const& i)
    {
        return map.begin()->second == i->second;
    };

    return std::all_of(map.begin(), map.end(), cmpWithFirst);
}

模板
布尔全等（标准：：映射常量和映射）
{
//lambda仅在映射不为空时才会被调用
//这样我们就可以安全地访问begin（）->second
自动常数cmpWithFirst=[&]（标准：：成对常数&i）
{
返回map.begin（）->second==i->second；
};
返回std:：all_of（map.begin（）、map.end（）、cmpWithFirst）；
}

---

这会将所有元素与第一个元素（如果有）进行比较，包括将第一个元素与第一个元素进行比较。

您甚至可以在不使用if语句的情况下使用std:：all\u检查空映射的情况下执行此操作，前提是您可以使用一个冗余比较：

template<typename Key, typename Value>
bool all_equal(std::map<Key, Value> const& map)
{
    // the lambda will only get called when the map is not empty
    // so we can safely access begin()->second
    auto const cmpWithFirst = [&](std::pair<Key,Value> const& i)
    {
        return map.begin()->second == i->second;
    };

    return std::all_of(map.begin(), map.end(), cmpWithFirst);
}

模板
布尔全等（标准：：映射常量和映射）
{
//lambda仅在映射不为空时才会被调用
//这样我们就可以安全地访问begin（）->second
自动常数cmpWithFirst=[&]（标准：：成对常数&i）
{
返回map.begin（）->second==i->second；
};
返回std:：all_of（map.begin（）、map.end（）、cmpWithFirst）；
}

---

这会将所有元素与第一个元素（如果有）进行比较，包括将第一个元素与第一个元素进行比较。

这不是一个有效的解决方案，因为

std:：unique

会修改映射。@Andrey:是的，但是OP要求使用“最简单”的方法（在“一次操作”中可行）；我假设

std:：unique

解决方案很短，但实际上可能不是（我开始怀疑

std:：unique

是否可以与

std:：map

迭代器一起使用，因为迭代器指向带有

const

第一个字段的一对）。这不是一个有效的解决方案，因为

std:：unique

会修改映射。@Andrey:True，但是OP要求的是“最简单”的方法（在“一次操作”中可行）；我假设

std:：unique

解决方案很短，但实际上可能不是（我开始怀疑

std:：unique

是否可以与

std:：map

迭代器一起使用，因为迭代器指向带有

const

第一个字段的一对）。这不是一个有效的解决方案，因为如果不提前终止，

count\u（函数可能会在发现第一个不匹配时立即返回）。；-）这不是一个有效的解决方案，因为如果

不提前终止，

count\u（函数可以在发现第一个不匹配时立即返回）。；-）std:：all_of是C++11顺便说一下std:：all_of是C++11