Namespaces

Argument-dependent lookup (ADL) — overview

• When you call f(x), C++ also looks in namespaces associated with the argument types (Koenig lookup).
• This is why std::cout << x can find operator<< in related namespaces.
• Be careful adding free functions in the same namespace as your types — they participate in ADL.

Inlining and splitting across files

• Declare in a header inside namespace App { void run(); } and define in a .cpp as void App::run() { ... } or inside another namespace App { ... } block.
• Keep headers free of using namespace directives so clients do not inherit unwanted names.
• Inline namespaces (advanced) can version ABIs — know they exist; use only when packaging libraries.

// app.h
namespace App {
    void run();
}

// app.cpp
#include 
#include <iostream>
void App::run() {
    std::cout << "Running\n";
}

Global namespace and :: prefix

• Names outside any namespace live in the **global namespace**.
• ::name forces lookup in the global namespace — useful when a local name shadows a global.

int value = 1;
namespace Demo {
    int value = 2;
    void show() {
        std::cout << value << "\n";   // 2
        std::cout << ::value << "\n"; // 1 global
    }
}

Real-life project layout

• Shop::Cart, Shop::Payment, Shop::Inventory modules.
• Game::Physics, Game::Render, Game::AI.
• Company::Util for shared helpers; anonymous namespace for file-private helpers.
• Third-party: nlohmann::json, sf:: (SFML-style prefixes) — always qualify at boundaries.

Basic Math namespace

#include <iostream>
using namespace std;

namespace Math {
    int add(int a, int b) { return a + b; }
    int mul(int a, int b) { return a * b; }
}

int main() {
    cout << Math::add(3, 4) << "\n";
    cout << Math::mul(3, 4) << "\n";
    return 0;
}

Avoiding name clash

#include <iostream>
using namespace std;

namespace Printer {
    void print(const char* s) { cout << "[Printer] " << s << "\n"; }
}
namespace Logger {
    void print(const char* s) { cout << "[Logger] " << s << "\n"; }
}

int main() {
    Printer::print("page 1");
    Logger::print("started");
    return 0;
}

using declaration — selective

#include <iostream>
#include <string>

int main() {
    using std::cout;
    using std::string;
    string name = "C++";
    cout << name << "\n";
    return 0;
}

Nested namespace + alias

#include <iostream>

namespace Shop {
    namespace Cart {
        int total = 0;
        void add(int price) { total += price; }
    }
}

namespace SC = Shop::Cart;

int main() {
    SC::add(50);
    SC::add(20);
    std::cout << SC::total << "\n"; // 70
    return 0;
}

Anonymous namespace helper

#include <iostream>

namespace {
    int clamp(int x, int lo, int hi) {
        if (x < lo) return lo;
        if (x > hi) return hi;
        return x;
    }
}

int main() {
    std::cout << clamp(150, 0, 100) << "\n"; // 100
    return 0;
}

Global vs namespace shadowing

#include <iostream>

int count = 1;

namespace App {
    int count = 2;
    void show() {
        std::cout << count << "\n";   // 2
        std::cout << ::count << "\n"; // 1
    }
}

int main() {
    App::show();
    return 0;
}

Fully qualified std usage

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3};
    for (int x : v) std::cout << x << " ";
    std::cout << "\n";
    return 0;
}