Mixing STL maps/vectors with templates

[DrLex]

This is a really annoying thing to look up in Google because all pages that mention STL maps or vectors will most likely also contain the word "template". So maybe this question has been asked before, but it's nearly impossible to find.

I'm having trouble using STL vectors, maps, ... in templated functions, when the templated class is a template parameter of the map too.
Below is a (cannibalized) example of a class 'Model' which contains several STL maps with different objects. I want to perform a similar operation on these different maps. Instead of writing nearly similar methods for each type of map, it would be much nicer to have a single template method. In the example below, the findStuff method returns a pointer to the object to be found, or NULL if it can't be found. This is of course rather useless because I could just use find() directly, but it's just an illustration.
Aside from having to add the 'typename' word which I'm not familiar with, the code compiles fine until I try to use findStuff, like:

string sName("someGroup");
Group *theGroup = findStuff( sName, m_mGroups );

This produces a linking error in GCC (4.1.1):
undefined reference to `Group* Model::findStuff<Group>(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::map<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, Group, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const>, std::allocator<std:: pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> > const, Group> > >&)'

I'm not too familiar with templates, so maybe I'm just making a silly error? However, it appears the template is correctly instantiated, only it can't be found by the linker?

/* Class code */
Class Model
{
public:
  map<const string, Group> m_mGroups;
  map<const string, Shape> m_mShapes;
 
  template <class T>
  T * findStuff( const string &sName, map<const string, T> &mMap );
};
 
template <class T>
T * Model::findStuff( const string &sName, map<const string, T> &mMap )
{
    typename map<const string, T>::iterator it = mMap.find(sName);
    if( it == mMap.end() )
        return NULL;
    return &(it->second);
}

[AdrianH]

Hi,

I'm sorry, but I'm not sure what you are trying to do. The code is incomplete (i.e. not compliable) and I don't have time to figure out what you are attempting. Oh, wait a minute, perhaps you were trying to do this?

#include "stdafx.h"
 
#include <string>
#include <map>
using namespace std;
 
struct Group{};
struct Shape{};
 
class Model
{
public:
  map<const string, Group> m_mGroups;
  map<const string, Shape> m_mShapes;
 
  template <class T>
  T * findStuff( const string &sName, map<const string, T> &mMap );
    void fn()
    {
        string sName("someGroup");
        Group *theGroup = findStuff( sName, m_mGroups );
    }
};
 
template <class T>
T * Model::findStuff( const string &sName, map<const string, T> &mMap )
{
    typename map<const string, T>::iterator it = mMap.find(sName);
    if( it == mMap.end() )
        return NULL;
    return &(it->second);
}
 
int main(int argc, char* argv[])
{
    Model a;
    a.fn();
    return 0;
}
 

This compiled and linked correctly (although there were lots of warning about identifiers being truncated due to being longer than 255 characters, but this is normal and can be ignored for the most part).

If this is what you are attempting, then I don't see why it doesn't link on your system. If it is not, please post a minimal, but compliable set of code so that it can be independently verified and tested and I will see what I can do.


Adrian

[DrLex]

Hi,

I'm sorry, but I'm not sure what you are trying to do. The code is incomplete (i.e. not compliable) and I don't have time to figure out what you are attempting. Oh, wait a minute, perhaps you were trying to do this?

Yes, that's roughly what I try to do, except that findStuff() would be called in a derived class of Model. The funny thing is that your code compiles on my system as well. So I did some more tests and it appears that the linking error occurs as soon as I put the definition of findStuff in a different file than the one in which it is called. For instance:
File "model.h":

#ifndef MODEL_H
#define MODEL_H
 
#include <map>
#include <string>
using namespace std;
 
struct Group{};
 
class Model
{
public:
    map<const string, Group> m_mGroups;
 
    template <class T>
    T * findStuff( const string &sName, map<const string, T> &mMap );
    void fn()
    {
        string sName("someGroup");
        Group *theGroup = findStuff( sName, m_mGroups );
    }
};
 
#endif // MODEL_H

File "model.cpp":

#include "model.h"
 
template <class T>
T * Model::findStuff( const string &sName, map<const string, T> &mMap )
{
    typename map<const string, T>::iterator it = mMap.find(sName);
    if( it == mMap.end() )
        return NULL;
    return &(it->second);
}

File "main.cpp":

#include "model.h"
 
int main(int argc, char* argv[])
{
    Model a;
    a.fn();
    return 0;
}

If I would define findStuff() in model.h, it works. But that's no solution in my case because I'd like to use it in a derived class of Model. And I simply want to know why it doesn't work of course :)

[mambazo]

You should read this:

http://gcc.gnu.org/onlinedocs/gcc/Template-Instantiation.html

Most of what is said applies to Visual Studio and other popular C++ compilers. Basically, the bottom line is that you _have_ to put the templated definitions in your header file, so that the entire definition is available at instantiation.

Also, I don't see why this is a problem if you want to call the function from a derived class.

[DrLex]

Most of what is said applies to Visual Studio and other popular C++ compilers. Basically, the bottom line is that you _have_ to put the templated definitions in your header file, so that the entire definition is available at instantiation.

OK, it's not a nice & clean solution, but it works. Thanks for pointing this out.

Also, I don't see why this is a problem if you want to call the function from a derived class.

This is indeed not a problem, my assumption that the definition must be in the very same file as where the method is called, was wrong (luckily).

[AdrianH]

Most of what is said applies to Visual Studio and other popular C++ compilers. Basically, the bottom line is that you _have_ to put the templated definitions in your header file, so that the entire definition is available at instantiation.

Yeah, this is a limitation of most C++ compilers. I don't know of one that actually allows you to do it any other way. It has to do with the format of the object files generated. They aren't able to store the necessary information. Sorta the same with inlining, though I think that compilers are starting to do a better job about that without having to put the inlined code available to everyone.


Adrian