Inline namespaces, anonymous namespaces

5.2.31 · Coding › C++ Programming

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 Compiler ACTUALLY kya karta hai (HOW it works)

Ek unnamed namespace ko is tarah treat kiya jaata hai jaise compiler ne har translation unit ke liye ek unique, hidden naam banaya ho, plus ek using directive:

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

Kyunki banaya gaya naam har .cpp mein alag hota hai, do files kabhi bhi collide nahi kar sakti. Isliye yeh internal linkage deta hai.

Worked example

static ki jagah ise kyun use karein? Purana C style:

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

Anonymous namespace har cheez ke liye kaam karta hai: functions, variables, types, templates, enums.

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

Yeh step kyun? C++ mein ek struct ko static-with-internal-linkage nahi banaya ja sakta; unnamed namespace modern, uniform tool hai.

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 names resolve karte hain

Caller likhta hai	Resolve hota hai	Kyun
`lib::process()`	`lib::v2::process()`	`v2` inline hai → uske names `lib` mein leak hote hain
`lib::v2::process()`	`lib::v2::process()`	explicit
`lib::v1::process()`	`lib::v1::process()`	explicit, opt-in to old version

Toh default callers automatically newest version par float karte hain, jabki jo v1 pin kiya hai woh kaam karta rehta hai. v3 release karne ke liye bas inline keyword move karo.

Figure — Inline namespaces, anonymous namespaces

Worked examples

Worked example Example 1 — Link error se bachna

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

Yeh step kyun? Har tag ek alag invented unnamed namespace mein rehta hai, toh linker do distinct symbols dekhta hai. Agar hum dono mein global scope par const char* tag likhte, toh "multiple definition of tag" aata.

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

Yeh step kyun? Naye users ko accurate v2 free mein milta hai; purana code jo mathx::v1::area likhta tha woh untouched hai. Migration ek keyword ka diff hai.

Worked example Example 3 — ADL inline ke through dekhta hai

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

Yeh step kyun? Kyunki impl inline hai, Widget ka associated namespace effectively ns ko include karta hai, toh unqualified draw(w) find ho jaata hai.

Common mistakes

Recall Feynman: 12-saal ke bacche ko samjhao

Socho ek school mein bahut saare classrooms hain. Anonymous namespace ek secret note hai jo tum EK classroom ke andar rakhte ho — doosre rooms ke bacche use nahi dekh sakte, aur agar do rooms mein "plan" naam ka note bhi ho, woh kabhi mix nahi hote. Inline namespace aise hai jaise kahein: "homework folder ka naaya version default folder hai." Jab koi bas "homework" maange, use latest mil jaata hai automatically — lekin agar specifically "last year's homework" maange, woh bhi mil sakta hai. Next year ka default banane ke liye, teacher bas "default" label naye folder par laga deta hai.

Recall

Flashcards

Anonymous namespace mein names ko kaunsi linkage milti hai?

Internal linkage — sirf apne translation unit mein visible hote hain.

Compiler unnamed namespace ke liye conceptually kya karta hai?

Har TU ke liye ek unique hidden naam banata hai aur ek implicit using directive add karta hai, taaki har file ki copy distinct rahe.

Internal linkage ke liye anonymous namespace ko static se kyun prefer karein?

Yeh uniformly variables, functions, AUR types/templates/enums ke liye kaam karta hai, sirf functions aur variables ke liye nahi.

Anonymous namespaces headers se bahar kyun rakhni chahiye?

Har include karne wale TU ko apni alag internal-linkage copy milti hai, duplication aur broken shared state hota hai.

inline namespace apne members ke saath kya karta hai?

Unhe enclosing namespace mein unqualified visible banata hai, jaise ek level upar declare kiye gaye hon; lookup, ADL, aur specialization ke liye woh same entity ban jaate hain.

Jab v2 inline ho, toh lib::process() kya resolve karta hai?

lib::v2::process() — callers automatically newest version par float karte hain.

Inline version use karte hue purane callers ko kaise kaam karta rakhte ho?

Purana namespace (jaise v1) non-inline rakhte hain; users ab bhi lib::v1::... explicitly call kar sakte hain.

Inline namespace ka naam mangled symbol mein kyun appear karta hai?

ABI versioning ke liye — alag versions ke against built objects distinct rehte hain taaki galat version silently link na ho sake.

Kya namespace par inline function par inline se related hai?

Nahi — same keyword, alag 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

WHY ye exist karte hain?

Anonymous (unnamed) namespaces

Inline namespaces

Worked examples

Common mistakes

Recall

Flashcards

Connections

Concept Map