Unnamed/anonymous namespaces vs. static functions?

Question

A feature of C++ is the ability to create unnamed (anonymous) namespaces, like so: namespace { int cannotAccessOutsideThisFile() { ... } } // namespace You would think that such a feature would be useless -- since you can't specify the name of the namespace, it's impossible to access anything within it from outside. But these unnamed namespaces *are* accessible within the file they're created in, as if you had an implicit using-clause to them. My question is, why or when would this be preferable to using static functions? Or are they essentially two ways of doing the exact same thing?

Answer 1

You are correct in that an unnamed namespace seems very similar to using the static keyword from C to create a function or variable with internal linkage (only visible in its own translation unit). However unnamed namespaces also allow you to specify typedefs and classes that are only visible within the translation unit. You can't specify a static class in C++.

This can allow you to have multiple essentially private classes with the same name across your project because anonymous namespaces across translation units are considered different by the compiler.

Subtle difference there and there may be more hiding in the C++ standard but in the common case of a static function or a variable they are extremely similar!