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.

Quote:

---

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?

Quote:

---

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.

Quote:

---

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.

Quote:

---

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!

Quote:

---

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.

Quote:

---

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 >_<

Quote:

---

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;

---

Quote:

---

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.