Another strange compiler error: calling a templated function which gives undefined referenes

Question

So far, so good. However, a few issues have arisen.

First and foremost, is that when I call the following:

const bool bppExists = CheckMapForExistingEntry< std::string, int >( mConfigValues, "bpp" );

I get the following:

error: undefined reference to `bool CheckMapForExistingEntry<std::string, int>(std::map<std::string, int, std::less<std::string>, std::allocator<std::pair<std::string const, int> > > const&, std::string const&)'

There are three other instances of where this is happening. The function looks as follows:

Declaration

template < class Key, class Value >
bool CheckMapForExistingEntry( const std::map< Key, Value >& map, const std::string& key );

Definition

template < class Key, class Value >
bool CheckMapForExistingEntry( const std::map< Key, Value >& map, const std::string& key )
{

    typename std::map< Key, Value >::iterator it = map.lower_bound( key );

    bool keyExists = ( it != map.end && !( map.key_comp() ( key, it->first ) ) );

    if ( keyExists )
    {
        return true;
    }

    return false;
}

Thus, what is happening here? I have the header file included which contains the declaration of the function, and yet it still doesn't work. According to this, I'm supposed to leave out the value of the template argument and just pass the key_type, however that refuses to work as well.

For example:

CheckMapForExistingEntry< std::string >( someMap, "somekey" ); //error

source file; declaration is in header. – zeboidlund Jan 28 '12 at 00:10 — zeboidlund, Jan 28 '12 at 00:10

score 2 · Accepted Answer · edited May 23 '17 at 10:34

2

You can't just easily split the declaration and the definition of templates between header and source file; thus templates are usually defined in headers. See e.g. "Why can templates only be implemented in the header file?".

Also you don't need to explicitly provide any type parameters in this case:

CheckMapForExistingEntry(m, "x");

The types Key and Value can be automatically deduced from the map type.

Note that your function can be significantly shortened, e.g.:

template < class Key, class Value >
bool contains(const std::map<Key, Value>& map, const std::string& key) {
    return map.find(key) != map.end();
}

Additionally you could generalize the type of the key parameter, making the function more reusable.

edited May 23 '17 at 10:34

Community

1
1

answered Jan 28 '12 at 00:13

Georg Fritzsche

97,545
26
194
236

The original code only requires that the search string can be compared with keys, not that it can be converted to the key type. – Ben Voigt Jan 28 '12 at 00:51
@Ben: But `lower_bound()` requires a `key_type` as a parameter? – Georg Fritzsche Jan 28 '12 at 00:58
You're right of course. `std::lower_bound` accepts any comparable value, but the `map` member function requires exactly the key type. – Ben Voigt Jan 28 '12 at 01:14

Another strange compiler error: calling a templated function which gives undefined referenes

1 Answers1