.containsKey() method for c++ map

Question

I want to save some repeating work and write a function that mimicks Java .containsKey() method.

Basically I would like to have something like this:

 using namespace std;
 map<string,XYclass> mymap;
 if (!contains(mymap,"key as string") ) cout << "key not found" << endl;

In C++ one can check, if a map contains key in following way:

 m.find(str) != m.end();

I want to write a generic method that returns true if a key is contained in a map.

So far I have following:

template<typename A, typename B> inline bool contains(const std::map< A, B > m, const A& str)
{
    return m.find(str) != m.end();
}

which will fail to do template argument deduction, when I run it on a map<string,int> with following call contains(mymap,"key as string"), as "key as string" is actually a char array.

Function works fine when I do explicit instantiation (i.e. by using following call contains<string,int>(mymap,"key as string"))

How to do it properly?

Answer 1

One can exclude parameters from template argument deduction with the below identity trick:

template <typename T>
struct identity { typedef T type; };

template <typename A, typename B>
inline bool contains(const std::map<A, B>& m
                   , const typename identity<A>::type& str)
{
    return m.find(str) != m.end();
}

DEMO

You don't need to specify type template arguments explicitly now.

---

To be precise, std::map has the total of four type template parameters:

template <typename A, typename B, typename Cmp, typename Alloc>
inline bool contains(const std::map<A, B, Cmp, Alloc>& m
                   , const typename identity<A>::type& str);

Answer 2

Don't hard-code it to std::map. The expression c.find( k ) != c.end() will work for any container with a find method returning an iterator. The function is applicable to any such types.

As others have noted, std::map has additional template parameters for the comparison function and the node allocator. In principle, listing all its parameters violates the separation of concerns.

template< typename container, typename key >
auto contains( container const & c, key const & k )
    -> decltype( c.find( k ) != c.end() )
    { return c.find( k ) != c.end(); }

The decltype specifier performs SFINAE, in case you want other overloads.