惯用的 C++ 用于从 const 映射中读取

Question

对于 std::map变量，我想这样做：

BOOST_CHECK_EQUAL(variables["a"], "b");

唯一的问题是，在这种情况下variables是const，所以operator[] 不起作用 :(

现在，有几种解决方法；使用 variables.count("a") 舍弃 const ？variables.find("a")- >第二：std::string() 或者甚至创建一个包装它的函数，在我看来，这些都不像 operator[] 那样好。有一个标准的方法可以做到这一点（漂亮地）吗？

编辑： 只是为了说明你们都不想给出的答案：不，在 C++ 中没有方便、漂亮、标准的方法来做到这一点。我将必须实现支持功能。

Answer 1

template <typename K, typename V>
V get(std::map<K, V> const& map, K const& key)
{
    std::map<K, V>::const_iterator iter(map.find(key));
    return iter != map.end() ? iter->second : V();
}

根据评论改进实施：

template <typename T>
typename T::mapped_type get(T const& map, typename T::key_type const& key)
{
    typename T::const_iterator iter(map.find(key));
    return iter != map.end() ? iter->second : typename T::mapped_type();
}

Answer 2

抛弃 const 是错误的，因为 map<> 上的operator[] 如果默认构造的字符串不存在，则将创建该条目。 如果映射实际上位于不可变存储中，那么它将失败。 这一定是这样，因为operator[]返回一个非常量引用以允许赋值。 （例如，m[1] = 2）

一个快速的免费函数来实现比较：

template<typename CONT>
bool check_equal(const CONT& m, const typename CONT::key_type& k,
                    const typename CONT::mapped_type& v)
{
    CONT::const_iterator i(m.find(k));
    if (i == m.end()) return false;
    return i->second == v;
}

我会考虑语法糖，如果我想到什么就更新。

...

直接的语法糖涉及一个自由函数，它执行map<>::find()并返回一个包装map<>::const_iterator的特殊类，然后重载了operator==()和operator! =() 允许与映射类型进行比较。 所以你可以这样做：

if (nonmutating_get(m, "key") == "value") { ... }

我不相信这比：

if (check_equal(m, "key", "value")) { ... }

它肯定要复杂得多，而且发生的事情不太明显。

包装迭代器的对象的目的是停止使用默认构造的数据对象。 如果您不在乎，则只需使用“获取”答案即可。

为了回应关于 get 优于比较的评论，希望找到一些未来的用途，我有以下评论：

• 说出你的意思：调用一个名为“check_equal”的函数可以清楚地表明你正在做一个不创建对象的相等比较。

• 我建议仅在您有需要时才实现功能。 在此之前做某事通常是一个错误。

• 根据具体情况，默认构造函数可能会产生副作用。 如果要进行比较，为什么要做额外的事情？

• SQL 参数：NULL 不等于空字符串。 容器中缺少密钥真的与容器中存在的具有默认构造值的密钥相同吗？

话虽如此，默认构造对象相当于在非常量容器上使用 map<>::operator[]。 也许您当前需要一个返回默认构造对象的 get 函数； 我知道我过去也有过这样的要求。

Answer 3

find 是惯用的形式。 抛弃 const 几乎总是一个坏主意。 您必须保证不执行任何写操作。 虽然这对于地图上的读取访问来说是合理的预期，但规范对此没有任何说明。

如果您知道该值存在，您当然可以放弃使用count进行测试（无论如何，这效率很低，因为这意味着遍历地图两次。即使您不这样做不知道该元素是否存在，我不会使用它，而是使用以下内容：

T const& item(map<TKey, T> const& m, TKey const& key, T const& def = T()) {
    map<TKey, T>::const_iterator i = m.find(key);
    return i == m.end() ? def : i->second;
}

/编辑：正如 Chris 正确指出的那样，T 类型的对象的默认构造可能 成本高昂，特别是因为即使实际上不需要该对象（因为该条目存在）也会这样做。如果是这种情况，请不要使用 def 参数的默认值。在上述情况下。

Answer 4

有趣的是，有两种方法可以在接受的 get 实现中进行模板类型发现（获取值或返回默认构造对象的方法）。 一，您可以执行已接受的操作：

template <typename K, typename V>
V get1(const std::map<K, V>& theMap, const K const key)
{
    std::map<K, V>::const_iterator iter(theMap.find(key));
    return iter != theMap.end() ? iter->second : V();
}

或者您可以使用映射类型并从中获取类型：

template<typename T>
typename T::mapped_type
get2(const T& theMap, const typename T::key_type& key)
{
    typename T::const_iterator itr = theMap.find(key);
    return itr != theMap.end() ? itr->second : typename T::mapped_type();
}

这样做的优点是传入的密钥类型不会在类型发现中发挥作用，并且可以是可以隐式转换为密钥的东西。 例如：

std::map<std::string, int> data;
get1(data, "hey"); // doesn't compile because the key type is ambiguous
get2(data, "hey"); // just fine, a const char* can be converted to a string

Answer 5

事实上，operator[] 是 std::map 上的非常量运算符，因为如果映射不存在，它会自动在映射中插入键值对。 （哦副作用！）

正确的方法是使用 map::find 并且，如果返回的迭代器有效 (!= map.end())，则返回第二，如您所示。

map<int, int> m;
m[1]=5; m[2]=6; // fill in some couples
...
map<int,int>::const_iterator it = m.find( 3 );
if( it != m.end() ) {
    int value = it->second;
    // ... do stuff with value
}

您可以在您正在使用的 std::map 的子类中添加 map::operator[]( const key_type& key ) const ，并将密钥断言为找到，然后返回 it->second。

Answer 6

std::map<std::string, std::string>::const_iterator it( m.find("a") );
BOOST_CHECK_EQUAL( 
                     ( it == m.end() ? std::string("") : it->second ), 
                     "b" 
                 );

这对我来说看起来不太糟糕......我可能不会为此编写函数。

Answer 7

遵循 xtofl 专门化地图容器的想法。 下面的方法效果好吗？

template <typename K,typename V>  
struct Dictionary:public std::map<K,V>  
{  
  const V& operator[] (const K& key) const  
  {  
    std::map<K,V>::const_iterator iter(this->find(key));  
    BOOST_VERIFY(iter!=this->end());  
    return iter->second;  
  }  
};