Function template specialization and duplicate symbols

Hi,

There's probably a simple way to get rid of this, but I just can't find it.

I have a class with two function templates. One of them calls the other, and the other one is defined with specializations.
The Foo class is defined in 3 files:

Foo.h

Code:

#pragma once

#include <map>
#include <vector>


class Foo
{
public:
	Foo();
	virtual ~Foo() {}
	
	int bar();
	
	template <typename T> std::vector<int> enum_keys() const;
	
	template <typename T> const std::map<int, T>& get_map() const;
	
protected:
	std::map<int, int>	_int_map;
	std::map<int, float> _float_map;
};

#include "Foo.hpp"

Foo.hpp

Code:

template <typename T>
std::vector<int> Foo::enum_keys () const
{
	std::vector<int> keys;
	
	const std::map<int, T>& mapref = get_map<T>();
	
	typename std::map<int, T>::const_iterator end = mapref.end();
	typename std::map<int, T>::const_iterator it = mapref.begin();
	for (; it != end; ++it)
	{
		keys.push_back(it->first);
	}
	
	return keys;
}

template <>
const std::map<int, int>& Foo::get_map<int>() const
{
	return _int_map;
}

template <>
const std::map<int, float>& Foo::get_map<float>() const
{
	return _float_map;
}

Foo.cpp

Code:

#include "Foo.h"

Foo::Foo()
{
}

int Foo::bar()
{
	const std::map<int, float>& floatmap = get_map<float>();
	return floatmap.begin()->first;
}

and here is my main:

Code:

#include "Foo.h"

int main(int argc, char** argv)
{
	Foo foo;
	
	return 0;
}

The linker gives me a duplicate symbol error I can't get rid of:

Code:

duplicate symbol __gnu_debug_def::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >
 const& Foo::get_map<int>() const in Foo.o and main.o

I believe there is a way to actually tell the compiler which templates to generate, but I haven't found the way yet...
Anyone can help me on this ?

You may want to use template traits:

Code:

template<typename T> class my_class_traits { };
template<> class my_class_traits<float>
{
protected:
    std::map<int, flat> m_Map;
};
// Repeat for int

template<typename T> class myclass: protected my_class_traits<T>
{
    // Use m_Map to access your map now.
}

No duplicate maps. No need for an access method, either.
Simple, easy and efficient.

Originally Posted by Elysia

You may want to use template traits:

Code:

template<typename T> class my_class_traits { };
template<> class my_class_traits<float>
{
    std::map<int, flat> m_Map;
};
// Repeat for int

template<typename T> class myclass: protected my_class_traits<T>
{
    // Use m_Map to access your map now.
}

No duplicate maps. No need for an access method, either.
Simple, easy and efficient.

I don't quite get where you would want me to use "myclass". As a member of Foo, or as replacement for Foo?

Case 1: Is that going to change anything, since map is already a template class? Isn't this just adding a layer?

Case 2: I need Foo/myclass to contain all the maps. I can instantiate only one Foo/myclass.

Is there another solution, without breaking my architecture too much?

Originally Posted by krappa

I don't quite get where you would want me to use "myclass". As a member of Foo, or as replacement for Foo?

It is your Foo. Myclass is basically your main class and the traits is the things you want to specialize depending on the type.

Case 1: Is that going to change anything, since map is already a template class? Isn't this just adding a layer?

Yes.
It does involve an extra, but again, you don't have TWO or MORE maps for every possible type NOR do you need your accessor function get_map, which you also specialize. So all in all, it's more efficient (less memory) and less typing in the end.

Case 2: I need Foo/myclass to contain all the maps. I can instantiate only one Foo/myclass.

But it's inheriting from the traits class, so your main class gets the appropriate map!

Is there another solution, without breaking my architecture too much?

This is the standard way to do things like these. It shouldn't break your architecture much. All you need to do is add the traits, and let the get_map function just return the generic map members that you inherit. Then you can remove the specialized functions, too.

But as for why you get a linker error, I can't say.
Although I do notice that your definition of the get_map function is wrong.
It should be:

Code:

template<typename T> template <>
const std::map<int, int>& Foo<T>::get_map<int>() const

The same for the rest.

Originally Posted by Elysia

But as for why you get a linker error, I can't say.
Although I do notice that your definition of the get_map function is wrong.
It should be:

Code:

template<typename T> template <>
const std::map<int, int>& Foo<T>::get_map<int>() const

The same for the rest.

Hmm, I still don't get it.
Foo isn't a class template, it's a normal class with two function templates.

Using your solution above, I'm going to have to instantiate Foo/Myclass specifying the type.
For example:

Code:

Foo<int> foo;

But in that case, foo is only going to contain one map, the map<int, int> m_Map it inherited. Right?

That's not what I want, I want foo to have all maps at all times. Think of Foo as an "address book" that maps different types. The list of maps can be arbitrary long, and I want a map for each type I decide.
In this example, bar() is the only method, but in my real-life case, I have loads of methods, all of them using enum_keys and specifying which template to use (int, float, object pointers...).

Either your solution is not what I'm trying to do, or I just don't get it. (example using Foo, please?)

Right. I mis-read the code and misread the purpose of the code. Sorry about that >_<

Originally Posted by krappa

I believe there is a way to actually tell the compiler which templates to generate, but I haven't found the way yet...

Move the definitions of those function template specialisations into Foo.cpp, and forward declare them in Foo.hpp:

Code:

template <>
const std::map<int, int>& Foo::get_map<int>() const;

template <>
const std::map<int, float>& Foo::get_map<float>() const;

Originally Posted by laserlight

Move the definitions of those function template specialisations into Foo.cpp, and forward declare them in Foo.hpp:

Code:

template <>
const std::map<int, int>& Foo::get_map<int>() const;

template <>
const std::map<int, float>& Foo::get_map<float>() const;

Great! That's the thing I was looking for.
Works like a charm.

Thanks laserlight.