Question

Inspired by contains(), I want do declare contains(), fitting misc containers.

// for std::vector, std::list, ..           (1)
template<typename C, typename T>
bool contains(const C& container, const T& val) 
{
    return ::std::find(container.begin(), container.end(), val) != container.end();
}

// partial specialization for std::map       (2)
template<typename K, typename V>
bool contains(const ::std::map<K, V>& container, const K& key)
{
   // std::map.find() is better than std::find used in (1)
    return container.find(key) != container.end(); 
}

Following question, I want to add the functions to namespace the arguments belongs too.

Questions:

1. Types of val from (1) and key from (2) are unknown. Does it mean I don’t need to put the functions to any namespace or do I need to put them in std namespace, the containers belong to?

2. Is it possible to improve (2) it will preferred by compiler than (1) for std::map, std::set, boost::unordered_map, boost::unordered_set?

3. boost::algorithm::contains(). Do I need choose another name for my wrapper?

Answer 1

(1) Don’t add anything to the std namespace

(2) As Space_C0wb0y points out, (2) is not a partial specialization, but an overload. I’m not sure if this is standard behaviour, but on VS2008 this is resolved correctly (the overloaded version is used for map). In either case, I think a slighly better version would be:

template<typename C>
bool contains(const C & mapContainer, const typename C::key_type & key)
{
  // std::map.find() is better than std::find used in (1)
  return mapContainer.find(key) != mapContainer.end(); 
}

This is a partial specialization (T is specialized to C::key_type) and would work for all types that has the key_type typedef (e.g. std::map, boost::unordered_map etc.)

(3) Put in separate namespace (see @Tony’s answer)

Sidenote: I’m not sure I think these functions should have the same name. If I saw a function contains() accepting a map + another argument I could think that (1) the function checks if the map contains an entry for the given value (e.g. some key has the value provided) or (2) the function checks if there is such an entry in the map (e.g. the provided value is a pair). Instead I would call the function contains_key() for maps.

Edit:
After a bit of checking I suspect that the code above isn’t compliant as it uses “template typedefs”. This is not a standard C++ feature, but it seems that Visual Studio supports it in some cases. There’s probably a workaround for this, but not one I’m clever enough to come up with now.