What if I need anonymous namespace in a header? - c++

Question

In C++ an anonymous namespace is equivalent to:
namespace $$$$ {
//something
}
using namespace $$$$;
Where $$$$ is some kind of unique identifier. Anonymous namespace are then useful for code that should not be seen outside the compilation unit.
So far so good, however recently I started to write some code with templates, such code must be in headers so using anonymous namespaces does not make much sense as the mere inclusion of the header will nullify the isolation effect.
Then the question is, what is the suggested way in this cases? I started using a named namespace called Private. It does not really stop anyone who wants to use the identifiers inside, but at least it reduces the name clashes to id "Private."
Are there better ways? Suggestions?

Answer 1

Stick with your Private namespace (or use the more popular detail). Remember the main idea behind C++ access mechanisms is make it difficult to misuse them, not impossible. Protect yourself against accidents, not malicious attacks.

Answer 2

If you're desperate for that isolation, why not the good old file-static? It was undeprecated:
template <typename T>
static void foo()
{}
int main()
{
foo<char>();
}
Then again, if you only need foo within one translation unit, then presumably you're only including it in a header within that translation unit, and then it doesn't matter whatsoever whether it's "in a header". So, simply do not include the templates in other translation units and you've already largely achieved your goal of isolation.
To really guarantee isolation for all possible instantiations (i.e. including those that you've created within this TU), use static as above or simply document your intent using a detail namespace.

Answer 3

The most usual way to hide implementation of template code within a header is to put the implementation into a namespace called detail.
For example:
namespace cpputil { // my c++ utility library namespace
namespace detail { // implementation details of this libraries headers go here
// a functor private to the library
template<class T>
struct private_functor {
private_functor(const T& t) : _t(t) {}
void write(std::ostream& os) const { _t.write(os); }
private:
const T& _t;
};
// an extension to std::ostream::operator<<
template<class T>
std::ostream& operator<<(std::ostream& os, const private_functor<T>& pf)
{
pf.write(os);
return os;
}
}
/// a public template function that is designed to allow an object to be emitted to a stream
/// returns a function object that calls T::write(std::ostream&) when placed into an
/// output stream
template<class T>
detail::private_functor emit(const T& t) {
return detail::private_functor<T>(t);
}
}
// can be used like this:
int main() {
struct S {
void write(std::ostream& os) const { os << "{I am an S}"; }
};
std::cout << cpputil::emit(S) << std::endl;
return 0;
}