<p>A feature of C++ is the ability to create unnamed (anonymous) namespaces, like so:</p>

<pre><code>namespace {
    int cannotAccessOutsideThisFile() { ... }
} // namespace
</code></pre>

<p>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 <em>are</em> accessible within the file they're created in, as if you had an implicit using-clause to them.</p>

<p>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?</p>

The C++ Standard reads in section 7.3.1.1 Unnamed namespaces, paragraph 2:
The use of the static keyword is
deprecated when declaring objects in a
namespace scope, the unnamed-namespace
provides a superior alternative.
Static only applies to names of objects, functions, and anonymous unions, not to type declarations.
Edit:
The decision to deprecate this use of the
```
static
```
keyword (affecting visibility of a variable declaration in a translation unit) has been reversed (
ref
).  In this case using a
```
static
```
or an unnamed
```
namespace
```
are back to being essentially two ways of doing the exact same thing.  For more discussion please see
this
SO question.
Unnamed
```
namespace
```
's still have the advantage of allowing you to define translation-unit-local types.  Please see
this
SO question for more details.
Credit goes to
Mike Percy
for bringing this to my attention.