In the immediately preceding post I discussed how a linker enforces access to a symbol from within a single translation unit. In that post I emphasized the usage of the static keyword because it is a shared approach across both C and C++. A more idiomatic approach in C++ would be to use an anonymous namespace. Usage of the static keyword for this purpose was actually deprecated in the C++ standard and then undeprecated. An example making use of anonymous namespaces is below:

static int count = 0;

// instead of static void incrementCount
namespace {
    void incrementCount() {
        count++;
    }
}

// Force the compiler not to skip incrementCount
void callIncrementCount() { incrementCount(); }

In light of the preceding post, a reasonable question to ask could be: "How does this work?" There are not many satisfactory answers available. Going straight to the primary source of authoritative but unsatisfactory answers on C++, cppreference.com states:

[An anonymous namespace definition] is treated as a definition of a namespace with unique name ... The unique name is unique over the entire program, but within a translation unit each [anonymous namespace] definition maps to the same unique name: multiple [anonymous namespace] definitions in the same scope denote the same [anonymous namespace].

Pardon the punctuation in the quote. CppReference also refers to anonymous namespaces as unnamed namespaces, which is a term that I have never heard used in practice. Beyond that, the definition is also incomplete. To see this, we can use the same approach in the preceding post.

$ clang++ -c lib.cpp
$ nm lib.o
0000000000000000 T __Z23callIncrementCountv
0000000000000068 b __ZL5count
0000000000000014 t __ZN12_GLOBAL__N_114incrementCountEv
0000000000000000 t ltmp0
0000000000000068 b ltmp1
0000000000000028 s ltmp2

The line 0000000000000014 t __ZN12_GLOBAL__N_114incrementCountEv shows the a symbols address, type, and name respectively. The type t indicates that the incrementCount function is not an exported symbol like it would have been if it were not wrapped in a namespace.

Interestingly, this is different than if we were to use a regular namespace. For example:

static int count = 0;

namespace foo {
    void incrementCount() {
        count++;
    }
}

void callIncrementCount() { foo::incrementCount(); }

The corresponding symbols are below:

$ clang++ -c lib.cpp
$ nm lib.o
0000000000000014 T __Z18callIncrementCountv
0000000000000068 b __ZL5count
0000000000000000 T __ZN3foo14incrementCountEv
0000000000000000 t ltmp0
0000000000000068 b ltmp1
0000000000000028 s ltmp2

So interestingly anonymous namespaces do not only result in a unique name being assigned to a symbol, but they also change the fact that they are exported by the object file.

Another fun thing that I discovered while trying to have prettify symbols was that extern "C" silently changes the behavior of anonymous namespaces, while erroring when combined with the static keyword. The example:

static int count = 0;

namespace {
    extern "C" void incrementCount() {
        count++;
    }
}

void callIncrementCount() { incrementCount(); }

Compiles to the symbols:

$ clang++ -c lib.cpp
$ nm lib.o
0000000000000014 T __Z18callIncrementCountv
0000000000000068 b __ZL5count
0000000000000000 T _incrementCount
0000000000000000 t ltmp0
0000000000000068 b ltmp1
0000000000000028 s ltmp2

When the example:

static int count = 0;

extern "C" static void incrementCount() {
    count++;
}

Fails to compile with the error:

clang++ -c lib.cpp
lib.cpp:3:12: error: cannot combine with previous 'extern' declaration specifier
    3 | extern "C" static void incrementCount() {
      |            ^
1 error generated.

This is kind of a toy example, but as I said it is fun. The nice thing about the results of this post is that you can make use of anonymous namespaces as a drop in for the static keyword and trust that they operate the same for pretty much all intents and purposes (outside of the last one).