Let's say:
- Some header
h.hppdefines a template functionf()usingsizeofon its template parameter. - Two different C++ source files,
a.cppandb.cpp, define their own structure having the same nameS. - Both
a.cppandb.cppusef()with their ownS.
In other words:
h.hpp:
template <typename T>
int f()
{
return something + sizeof(T);
}
a.cpp:
#include "h.hpp"
struct S {
int a;
int b;
};
int aFunc()
{
return f<S>();
}
b.cpp:
#include "h.hpp"
struct S {
int w;
int x;
int y;
int z;
};
int bFunc()
{
return f<S>();
}
Here, within the same program, both aFunc() and bFunc() return the same value. This is because both structures are named S, and only one template function instantiation is kept.
My working solutions so far are:
- Name the structures differently.
- Make
f()static. - Make
f()part of an anonymous namespace. - Make both structures part of their own anonymous namespace.
Can you think of anything else to avoid this issue which only manifests at run time?
I need to end this.
Considering the comments of n. 1.8e9-where's-my-share m. and VainMan: such a program is indeed ill-formed (ODR violation).
Therefore, the only legal solutions are those (1 and 4):
I somehow stopped reading the One Definition Rule section at:
But there's another important condition:
This is obviously not my case.
The outcome of not satisfying any of those conditions is: