linker complains about multiple definition even there are inclusion guards - c++

Question

I can't figure out why the code does not compile, even when I have the include guards to prevent repetitive compilation
The main class foo.h:
#ifndef FOO_H_INCLUDED
#define FOO_H_INCLUDED
#include <iostream>
class Foo;
template<int TDim>
struct Foo_Helper
{
static bool Compare(const Foo& this_foo, const Foo& other_foo);
};
class Foo
{
public:
Foo(const int& Value) : mValue(Value) {}
virtual ~Foo() {}
const int& Value() const {return mValue;}
template<int TDim>
bool Compare(const Foo& rother_foo) {return Foo_Helper<TDim>::Compare(*this, rother_foo);}
private:
int mValue;
};
#endif
#include "foo.hpp"
foo.hpp to define the template specialization:
#ifndef FOO_HPP_INCLUDED
#define FOO_HPP_INCLUDED
template<>
bool Foo_Helper<1>::Compare(const Foo& this_foo, const Foo& other_foo)
{
return this_foo.Value() == other_foo.Value();
}
template<>
bool Foo_Helper<2>::Compare(const Foo& this_foo, const Foo& other_foo)
{
return this_foo.Value() == other_foo.Value();
}
#endif
The two source files:
src1.cpp:
#include "foo.h"
class Test1
{
public:
bool test()
{
Foo f1(1);
Foo f2(2);
return f1.Compare<1>(f2);
}
};
src2.cpp:
#include "foo.h"
class Test2
{
public:
bool test()
{
Foo f1(1);
Foo f2(2);
return f1.Compare<2>(f2);
}
};
CMakeLists.txt:
set(file_list
src1.cpp
src2.cpp
)
add_library(Test SHARED ${file_list})
The error messsage:
Linking CXX shared library libTest.so
CMakeFiles/Test.dir/src2.cpp.o: In function `Foo_Helper<1>::Compare(Foo const&, Foo const&)':
/home/hbui/workspace/c++/multiple_definition_error/foo.hpp:7: multiple definition of `Foo_Helper<1>::Compare(Foo const&, Foo const&)'
CMakeFiles/Test.dir/src1.cpp.o:/home/hbui/workspace/c++/multiple_definition_error/foo.hpp:7: first defined here
CMakeFiles/Test.dir/src2.cpp.o: In function `Foo_Helper<2>::Compare(Foo const&, Foo const&)':
/home/hbui/workspace/c++/multiple_definition_error/foo.hpp:13: multiple definition of `Foo_Helper<2>::Compare(Foo const&, Foo const&)'
CMakeFiles/Test.dir/src1.cpp.o:/home/hbui/workspace/c++/multiple_definition_error/foo.hpp:13: first defined here
collect2: error: ld returned 1 exit status
make[2]: *** [multiple_definition_error/libTest.so] Error 1
make[1]: *** [multiple_definition_error/CMakeFiles/Test.dir/all] Error 2
make: *** [all] Error 2
I thought the inclusion guard has prevented the two functions in foo.hpp to be compiled. However, it looks like that each cpp file compile its own functions. In this case, how to properly define the template specialized functions?

Answer 1

The header guards stop the header being included twice in the same translation unit. Your problem is that the definitions of the Compare specializations will be defined in two translation units, but are not marked inline. This means that when the linker tries to link the object files produced by test1.cpp and test2.cpp, it gives you a multiple definition error. If you mark the specializations as inline then they can be defined in two TUs and the linker will just throw away one of the definitions:
template<>
inline bool Foo_Helper<1>::Compare(const Foo& this_foo, const Foo& other_foo)
//^^^^
{
return this_foo.Value() == other_foo.Value();
}
template<>
inline bool Foo_Helper<2>::Compare(const Foo& this_foo, const Foo& other_foo)
//^^^^
{
return this_foo.Value() == other_foo.Value();
}

Answer 2

You can also put specialization code in .cpp. I think it may be the best solution since specialization (usually) is closely related to the newly created classes (Test1 and Test2).
Alternatively put
template<>
bool Foo_Helper<1>::Compare(const Foo& this_foo, const Foo& other_foo)
{
return this_foo.Value() == other_foo.Value();
}
template<>
bool Foo_Helper<2>::Compare(const Foo& this_foo, const Foo& other_foo)
{
return this_foo.Value() == other_foo.Value();
}
into foo.cpp (instead of foo.hpp) and in foo.hpp only say that specialization is "extern".
Additionally you should move class declarations from src1.cpp to src1.hpp ;)