Inline namespaces, anonymous namespaces

Anonymous (unnamed) namespaces

// file_a.cpp
namespace {            // <-- no name
    int secret = 42;
    int helper() { return secret * 2; }
}
int useIt() { return helper(); }   // OK, same file

Intuition WHAT the compiler actually does (HOW it works)

An unnamed namespace is treated as if the compiler invented a unique, hidden name per translation unit, plus a using directive:

namespace __unique_to_this_file {
    int secret = 42;
}
using namespace __unique_to_this_file;   // implicitly added

Because the invented name is different in every .cpp, no two files can ever collide. That is WHY it gives internal linkage.

Worked example Why use it instead of

static? Old C style:

static int helper() { ... }   // internal linkage, but only works for functions/vars

The anonymous namespace works for everything: functions, variables, types, templates, enums.

namespace { struct Cache { int n; }; }   // Cache is file-local — static can't do this for a type

Why this step? A struct cannot be static-with-internal-linkage in C++; the unnamed namespace is the modern, uniform tool.

Inline namespaces

namespace lib {
    inline namespace v2 {      // current version
        void process() { /* new code */ }
    }
    namespace v1 {             // old version, NOT inline
        void process() { /* old code */ }
    }
}

Intuition HOW callers resolve names

Caller writes	Resolves to	Why
`lib::process()`	`lib::v2::process()`	`v2` is inline → its names leak into `lib`
`lib::v2::process()`	`lib::v2::process()`	explicit
`lib::v1::process()`	`lib::v1::process()`	explicit, opt-in to old version

So default callers float forward to the newest version automatically, while anyone who pinned v1 keeps working. To release v3 you just move the inline keyword.

Figure — Inline namespaces, anonymous namespaces

Worked examples

Worked example Example 1 — Avoiding a link error

// logger.cpp
namespace { const char* tag = "LOG"; }   // file-local
// metrics.cpp
namespace { const char* tag = "MET"; }   // different symbol, no clash

Why this step? Each tag lives in a different invented unnamed namespace, so the linker sees two distinct symbols. Had we written const char* tag at global scope in both, we'd get "multiple definition of tag".

Worked example Example 2 — Versioned math library

namespace mathx {
    namespace v1 { double area(double r){ return 3.14*r*r; } }
    inline namespace v2 { double area(double r){ return 3.14159*r*r; } }
}
 
double a = mathx::area(2.0);       // calls v2 (more precise) automatically
double b = mathx::v1::area(2.0);   // explicit legacy call

Why this step? New users get the accurate v2 for free; old code that wrote mathx::v1::area is untouched. Migration is a one-keyword diff.

Worked example Example 3 — ADL sees through inline

namespace ns {
    inline namespace impl { struct Widget {}; void draw(Widget){} }
}
ns::Widget w;
draw(w);   // found by ADL: impl is inline, so draw is "in" ns

Why this step? Because impl is inline, Widget's associated namespace effectively includes ns, so unqualified draw(w) is found.

Common mistakes

Recall Feynman: explain to a 12-year-old

Imagine a school with many classrooms. An anonymous namespace is a secret note you keep inside ONE classroom — kids in other rooms can't see it, and even if two rooms have a note called "plan", they never mix up. An inline namespace is like saying: "the newest version of the homework folder is the default folder." When someone just asks for "the homework," they get the latest one automatically — but if they specifically ask for "last year's homework," they can still get that too. To make next year's the default, the teacher just sticks the "default" label on the new folder.

Recall

Flashcards

What kind of linkage do names in an anonymous namespace get?

Internal linkage — visible only within their own translation unit.

What does the compiler conceptually do for an unnamed namespace?

Invents a unique hidden name per TU and adds an implicit using directive, so each file's copy is distinct.

Why prefer an anonymous namespace over static for internal linkage?

It works uniformly for variables, functions, AND types/templates/enums, not just functions and variables.

Why must anonymous namespaces stay out of headers?

Each including TU gets its own separate internal-linkage copy, causing duplication and broken shared state.

What does inline namespace do to its members?

Makes them visible in the enclosing namespace unqualified, as if declared one level up; they become the same entity for lookup, ADL, and specialization.

When v2 is inline, what does lib::process() resolve to?

lib::v2::process() — callers float forward to the newest version automatically.

How do you keep old callers working while inline-ing a new version?

Keep the old namespace (e.g. v1) non-inline; users can still call lib::v1::... explicitly.

Why does the inline namespace name appear in the mangled symbol?

For ABI versioning — objects built against different versions stay distinct so the wrong version can't be linked silently.

Is inline on a namespace related to inline on a function?

No — same keyword, unrelated meaning (versioning/visibility vs ODR/linkage of definitions).

Connections

Namespaces (basics)
Translation units and the One Definition Rule
Internal vs external linkage
static keyword (storage & linkage)
Argument-Dependent Lookup (ADL)
Name mangling and the ABI
API versioning strategies

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, namespace ka kaam hai naam ka jhagda (collision) rokna. Do special types hain. Pehla, anonymous namespace — jab tum namespace { ... } likhte ho bina naam ke, to uske andar ki har cheez sirf usi .cpp file ke andar dikhti hai (internal linkage). Compiler andar-andar ek unique chhupa hua naam bana deta hai, isliye do alag files me same naam helper ho to bhi linker confuse nahi hota. Ye purane C wale static ka modern aur powerful replacement hai, kyunki ye functions hi nahi, types aur templates pe bhi chalta hai.

Ek bada warning: anonymous namespace ko header file me kabhi mat daalo. Header har .cpp me copy hota hai, to har file me alag-alag copy ban jayegi — binary phool jayega aur shared state tut jayega. Isko sirf .cpp me rakho.

Dusra hai inline namespace — ye API versioning ke liye gold hai. Maano tumhari library lib me v1 aur v2 dono hain, aur tum v2 ko inline bana dete ho. Ab jo banda sirf lib::process() likhega, usko automatically latest v2 mil jayega. Aur jisko purana chahiye wo lib::v1::process() explicitly maang lega. Agle saal v3 release karna ho to bas inline keyword v3 pe shift kar do — caller ka code badalna nahi padega. Ek aur baat: inline namespace ka naam linker symbol (mangling) me chhup jata hai, isliye galat version galti se link nahi hota — ye safety feature hai, bug nahi. Yaad rakho: Anonymous = file ke andar Akela, Inline = default version.

WHY do these exist?

Anonymous (unnamed) namespaces

Inline namespaces

Worked examples

Common mistakes

Recall

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — C++ Programming