function template overloading - ordering - c++

Question

I don't get it. I know function templates are evil, but in this case we have to use it. So this is not the matter. We have an archive that uses a template-operator-function. The specialisation for objects/vale types follows after the template function declaration/definition:
class BaseArchive
{
public:
BaseArchive() {}
virtual ~BaseArchive();
template< typename T >
BaseArchive & operator<<(const T &t)
{
::operator<<(*this, t);
return *this;
}
};
BaseArchive & operator<<(BaseArchive &ar, const int & i)
{
return ar;
}
class StdArchive : public BaseArchive
{
public:
StdArchive();
template< typename T >
StdArchive & operator<<(const T &t)
{
::operator<<(*this, t);
return *this;
}
};
int main()
{
BaseArchive ar;
int i = 7;
ar << i;
}
For this example we get an error:
::operator<< has not been declared
This one can be fixed by a forward declaration of
class BaseArchive;
BaseArchive & operator<<(BaseArchive &ar, const int & i);
class Archive { ...
So far so good. But afterwards some classes define their own ::operator for the archive and thus it hard or even not possible to ensure that the specific operator declaration occurs always before the archive-header-include nor even we want to use an global operator inlcude file.
Any idea how to solve this and/or a explanation why this error occurs? As usual the VS-compiler soesn't care about that, but the minGW (gcc) compiler does...
many thanks

Answer 1

First, function templates aren't evil. Where did you get that idea?
Second, your setup doesn't make sense. Why is the member function template operator << there? It does nothing except forward to a global version, and because it uses explicit qualification, ADL doesn't apply.
Just remove the member function template and rely on ADL to find the correct operator<<.

Answer 2

Why no freestanding operators and forwarding:
#include<iostream>
struct BaseArchive {};
BaseArchive & operator<<(BaseArchive &ar, const int & i)
{
std::cout << "BaseArchive\n";
return ar;
}
struct StdArchive : BaseArchive {};
template< typename T >
StdArchive& operator<<(StdArchive& archive, const T &t)
{
std::cout << "StdArchive\n";
operator << (static_cast<BaseArchive&>(archive), t);
return archive;
}
int main()
{
StdArchive ar;
ar << 7;
}