Inline namespaces, anonymous namespaces: Visual walkthrough

5.2.31 · D2 · Coding › C++ Programming › Inline namespaces, anonymous namespaces

Yeh page Inline namespaces, anonymous namespaces ki companion hai. Yeh Namespaces (basics), Translation units and the One Definition Rule, aur Internal vs external linkage par rely karti hai.

Step 1 — Compiling shuru hone ke baad ek "name" hota kya hai?

WHAT: Hum duniya ko do rooms mein split karte hain — compiler (ek file par kaam karta hai) aur linker (saari finished files ko jodta hai).

WHY: Namespaces ke baare mein har rule asal mein yeh rule hai ki kaun sa room kaun sa box dekh sakta hai. Agar hum do rooms ko picture nahi karte, toh rules arbitrary magic jaisi lagti hain.

PICTURE: Step 1 dekho. Do files mein se har ek ek TU ban jaati hai; har TU boxes produce karti hai; neeche linker har box ko ek table mein collect karta hai.

Figure — Inline namespaces, anonymous namespaces

Step 2 — Linkage: kaun se boxes linker ko visible hain?

WHAT: Hum har box ko "external" (public label) ya "internal" (private label) tag karte hain.

WHY: Ek One Definition Rule violation — woh dreaded "multiple definition" link error — tabhi hoti hai jab do external boxes ek hi label share karte hain. Internal boxes kabhi clash nahi kar sakte, kyunki linker unhe kabhi dekhta hi nahi.

PICTURE: Step 2 mein, external boxes ka ek solid orange handle shared table mein jaata hai; internal boxes mein teal padlock hai aur koi handle nahi.

external by default int x; internal static int y;

x — ek plain global: iska label public jaata hai, isliye do files jo x define karti hain clash karti hain.
y — file scope par static mark kiya gaya: label private rehta hai, isliye do files mein se har ek mein static int y hona theek hai.

Step 3 — Anonymous namespace = ek auto-generated private room

WHAT: Hum bina naam ka namespace likhte hain aur apna helper uske andar daalte hain.

namespace {          // no name
    int secret = 42;
}

WHY: Hum static jaisa internal-linkage effect chahte hain, lekin kisi bhi cheez ke liye — variables, functions, types, templates. static kisi struct ko file-local nahi bana sakta; unnamed namespace bana sakta hai.

HOW (mental rewrite): Compiler upar diye code ko aise treat karta hai jaise tumne ek secret, per-file, one-of-a-kind naam wala namespace likha ho, phir use turant scope mein pull kar liya:

namespace unique per file__TU7a {int secret=42;} using namespace __TU7a;

__TU7a — ek invented label jo har .cpp mein alag hota hai. Kyunki file A ka __TU7a hai aur file B ka __TU9k hai, unke secrets ke alag mangled symbols hote hain (dekho Name mangling and the ABI) aur kabhi clash nahi kar sakte.
using namespace __TU7a; — implicitly add hota hai taaki tum ab bhi is file ke andar bina qualification ke sirf secret type kar sako.

PICTURE: Step 3 do files dikhata hai; har ek secret ke around apna uniquely-labeled private room grow karta hai. Do rooms kabhi touch nahi karte.

Step 4 — Edge case: do files mein same helper naam

WHAT: Dono logger.cpp aur metrics.cpp const char* tag define karte hain.

WHY: Yeh exactly wahi collision hai jo Step 2 ne warn kiya tha — jab tak hum har ek ko anonymous namespace mein wrap nahi karte.

PICTURE: Step 4 ek side-by-side hai. Left: bare globals → do identical labels linker table se takraate hain → red CLASH. Right: har ek apne unnamed namespace mein wrapped → do alag mangled labels → green OK.

file A’s private tag_ZN12_GLOBAL__N_L3tagE \neq = file B’s private tag_ZN12_GLOBAL__N_M3tagE

Do mangled strings invented middle piece mein differ karti hain, isliye linker unhe do unrelated boxes ki tarah file karta hai.

Step 5 — Ab opposite goal: hum CHAHTE hain ki naam escape kare

WHAT: Chhupaane ki jagah, hum chahte hain ki lib::v2::process chhote naam lib::process ko bhi answer kare.

WHY: API versioning. Customers ne lib::process() likha. Hum chahte hain ki unka code zero edits ke saath newest version par float forward kare, jabki ek customer jo lib::v1::process() pin kar chuka hai woh purana behavior rakhe.

namespace lib {
    inline namespace v2 { void process(); }   // current default
    namespace v1        { void process(); }   // opt-in legacy
}

PICTURE: Step 5 lib room dikhata hai jisme do sub-rooms hain, v1 (band darwaza) aur v2 (khula archway labeled inline). Archway ke through, process lib wall par bhi visible hai.

Step 6 — `inline` actually lookup mein kya karta hai

WHAT: Hum teen tarike trace karte hain jisme caller naam likh sakta hai aur har ek kahan jaata hai.

Caller likhta hai	Resolve hota hai	WHY
`lib::process()`	`lib::v2::process()`	`v2` inline hai → uske members `lib` mein leak ho jaate hain
`lib::v2::process()`	`lib::v2::process()`	explicit, same box
`lib::v1::process()`	`lib::v1::process()`	explicit opt-in; `v1` inline nahi hai

WHY yeh plain using se better hai: Ek using namespace v2; naam ko visible bana deta, lekin lib::v2::T aur lib::T template specialization ke liye aur mangled symbol ke liye alag entities rehte. inline unhe fuse karta hai, aur version linker symbol mein bake in ho jaata hai (_ZN3lib2v17processEv) — dekho Name mangling and the ABI.

PICTURE: Step 6 ek lookup flow hai: query lib::process lib mein jaati hai, inline archway dekhti hai, aur v2::process par pahunchti hai; same box ek mangled label carry karta hai jisme 2v2 embedded hai.

Step 7 — Edge case: ADL archway ke through dekhta hai

WHAT: Ek unqualified call draw(w) jahan w ka type ek inline namespace mein rehta hai.

namespace ns {
    inline namespace impl { struct Widget {}; void draw(Widget){} }
}
ns::Widget w;
draw(w);   // found — no ns:: needed

WHY: Argument-Dependent Lookup (ADL) functions ko argument ke type ke associated namespaces mein dhundhta hai. Kyunki impl inline hai, Widget ka associated namespace effectively ns ko include karta hai, isliye draw aise reachable hai jaise woh directly ns mein rehta ho.

PICTURE: Step 7: argument w dotted "search here" rays dono impl mein aur — inline archway ke through — ns mein bhejta hai, draw ko pakad leta hai.

Step 8 — Edge case: do libraries, dono `inline namespace v1`

WHAT: LibFoo aur LibBar dono inline namespace v1 ship karte hain. Kya woh merge ho jaate hain?

WHY: Log silent mixing se darte hain. Lekin inline naam mangled symbol ka part hai, aur do libraries alag enclosing namespaces (foo::v1::... vs bar::v1::...) mein rehti hain, isliye unke symbols differ karte hain. Same library ke bhi, alag-version objects alag mangled symbols produce karte hain → linker unhe alag rakhta hai ya silently galat code call karne ki jagah loudly fail karta hai. Yahi intended ABI-tagging hai (dekho static keyword (storage & linkage) us purane, coarser tool ke liye jo ise replace karta hai).

PICTURE: Step 8: do symbol strings side by side, differing version segment plum mein highlighted — proof ki woh kabhi ek box mein collapse nahi hote.

Ek-picture summary

Har box par ek hi sawaal compress hota hai: kya iska label file se bahar jaata hai, aur agar jaata hai, toh kis naam se?

Anonymous namespace → padlock: label ek per-file secret naam mein wrap hota hai, kabhi shared table tak nahi pahunchta → koi collision possible nahi.
Plain namespace → labeled box shared table mein apne full path ke under.
Inline namespace → labeled box plus ek shortcut arrow: enclosing naam bhi kaam karta hai, aur version symbol mein stamp ho jaata hai.

Recall Poore walkthrough ki Feynman retelling

Har file ek room hai. Jab ek room finish hoti hai, woh linker ko names wale boxes ka ek stack deti hai. Do rooms ek hi naam wale boxes deti hain toh fight hoti hai (link error).

Ek anonymous namespace ek room ke andar ek private drawer hai: compiler secretly us room ke unique tag se usme har cheez rename kar deta hai, isliye agar do rooms dono "tag" naam ka ek box rakhti hain, unke real names differ karte hain aur koi fight kabhi nahi hoti. (Woh drawer kabhi header mein mat rakho, kyunki header har room mein copy hoti hai, har ek ko apna alag drawer deti hai.)

Ek inline namespace opposite wish hai: tumhare paas bade cupboard lib ke andar ek labeled cupboard v2 mein ek box hai, aur tum v2 ka darwaza khula chhodh dete ho taaki box plain lib naam ko bhi answer kare. Naye visitors jo sirf lib::process maangte hain woh seedha newest version par pahunch jaate hain; purane visitors jo lib::v1::process par insist karte hain unhe purana apne band darwaze ke peeche mil jaata hai. Aur kyunki version box ke real naam mein likha hota hai, alag versions ke boxes kabhi confused nahi hote — yeh safety feature hai, bug nahi.

Recall

Empty label test

Unnamed namespace mein ek naam ko internal linkage milta hai — uska symbol shared linker table mein kabhi listed nahi hota.

One-keyword release

Ek new version ko default banane ke liye, inline keyword use mein shift karo.