具有STL容器成员的模板类

Question

I'm writing a template class that uses a std::multimap as a member, and getting compile errors.

LocTree.h:

#pragma once
#include <map>

template <class Loc, class T>
class LocTree
{
public :
         typedef std::multimap<typename Loc, typename T> TreeType;

        LocTree( void );
        ~LocTree( void ) { };
private :
        TreeType db;
};

LocTree.cpp:

#include "StdAfx.h"
#include "LocTree.h"

LocTree< class Loc, class T>::LocTree()
{
}

The compile error (from VC2005) :

Error     1     error C2079: 'std::pair<_Ty1,_Ty2>::first' uses undefined class 'Loc'     c:\program files (x86)\microsoft visual studio 8\vc\include\utility     53
Error     2     error C2079: 'std::pair<_Ty1,_Ty2>::second' uses undefined class 'T'     c:\program files (x86)\microsoft visual studio 8\vc\include\utility     54

I know I could put the function definitions in the .h but I'm hoping to keep them separate, if it's legal to do so. How do I fix this (probably newbie) problem?

Answer 1

Your constructor definition should be:

template<class Loc, class T>
LocTree<Loc,T>::LocTree()
{
}

Also, hoping to keep them separate... - don't - you're wasting your time. The only way to keep them separate is to have a definition in a different header which you also include. So, technically, they are separate, but the implementation is still visible.

Answer 2

Two points. The first is: what is:

typedef std::multimap<typename Loc, typename T> TreeType;

supposed to mean? I don't see what the typename are doing in there; I think you just want:

typedef std::multimap<Loc, T> TreeType;

Second, when defining a member function of a class template outside of the class, the syntax is:

template <typename Loc, typename T>
LocTree<Loc, T>::LocTree()
{
}

In other words, you have to repeat the template<...> clause. (Whether you use typename or class in the <...> is indifferent. Since it doesn't have to be a class, Most people I know prefer typename , since this corresponds closer to what is meant.)

As for keeping the implementation separate: templates in C++ are somewhat broken in this respect. You can't avoid the compiler dependency. You still do want to keep the implementation separate from the definition, however. The usual technique is to put the template implementation in a separate file ( .tcc , for example), and include this from the header.

Answer 3

Keeping the implementation of a template separate is not a trivial thing to do.

In general it cannot be done. That is, it cannot be done where the templated parameters may be "anything".

For a specific limited subset of templated parameters it is possible to do, for example if you have a template like:

template< bool B > class Foo;

You can then specify:

extern template class Foo<true>;
extern template class Foo<false>;

and this is called "instantiating" the templates, and specifying to the compiler that there are implementations for values true and false, implemented elsewhere.

This can also be done where the templated parameters are types and are limited to a specific subset.

Within the compilation unit you then define the template implementations and then instantiate the templates once again using the same as above but without the word "extern".

I have done this in production code in a case where you are creating a member function to set a parameter value for a database stored-procedure call where only a very limited subset of parameter types are permitted. If your types are a very limited subset then go ahead and do the same if this helps decouple the code and hide a lot of implementation detail (in the case where the implementation is then done in a database, it is well worth doing).

There is an "in-between" ground where you provide the implementation in another header, often I have seen _i.h or similar for this convention and then you instantiate the templates in ones, including this header only when necessary. Thus if you create a class Foo then in the header use the "extern" declaration for my foo class in Foo.h and in Foo.cpp , #include the _i.h file for the implementation and the instantiation.

As for the syntax, in the template implementation file use:

template<class Loc, class T>
LocTree<Loc,T>::method(...)
{
  ...
}