Namespace in C++

#include <iostream>
using namespace std;

// Dichiarazione namespace
namespace geometria {
    const double PI = 3.14159265358979;

    double area_cerchio(double r) { return PI * r * r; }
    double perimetro_cerchio(double r) { return 2 * PI * r; }

    struct Punto {
        double x, y;
        double distanza(const Punto &altro) const {
            double dx=x-altro.x, dy=y-altro.y;
            return sqrt(dx*dx+dy*dy);
        }
    };

    // Namespace annidato
    namespace forme3d {
        double volume_sfera(double r)   { return (4.0/3.0) * PI * r * r * r; }
        double volume_cilindro(double r, double h) { return PI * r * r * h; }
    }
}

// I namespace possono essere "aperti" più volte
namespace geometria {
    double area_triangolo(double b, double h) { return 0.5 * b * h; }
}

int main() {
    // Accesso qualificato
    cout << geometria::area_cerchio(5.0) << "\n";
    cout << geometria::PI << "\n";

    // Accesso namespace annidato
    cout << geometria::forme3d::volume_sfera(3.0) << "\n";

    // using declaration: porta UNO specifico nome
    using geometria::Punto;
    Punto p1{0, 0}, p2{3, 4};
    cout << "Distanza: " << p1.distanza(p2) << "\n";

    // using directive: porta TUTTO il namespace (sconsigliato nei header!)
    // using namespace geometria;
    // area_cerchio(5.0);  // OK dopo using namespace

    // Alias di namespace
    namespace geo3d = geometria::forme3d;
    cout << "Volume cilindro: " << geo3d::volume_cilindro(2, 5) << "\n";

    return 0;
}

#include <iostream>
using namespace std;

// Namespace anonimo: visibile SOLO in questo file
// Equivale a "static" in C — evita conflitti tra file diversi
namespace {
    int helper_privato(int x) { return x * x; }
    const int COSTANTE_LOCALE = 42;
}

// Inline namespace: per versioning di API
namespace libreria {
    inline namespace v2 {  // Versione corrente (default)
        void funzione() { cout << "libreria::v2::funzione\n"; }
        int nuova_api() { return 42; }
    }
    namespace v1 {  // Versione vecchia (accesso esplicito)
        void funzione() { cout << "libreria::v1::funzione (obsoleta)\n"; }
    }
}

int main() {
    // Il namespace anonimo è accessibile nel file corrente
    cout << helper_privato(5) << "\n";       // 25
    cout << COSTANTE_LOCALE << "\n";          // 42

    // Inline namespace: accesso senza qualifica (usa v2)
    libreria::funzione();          // chiama v2
    libreria::v1::funzione();      // chiama v1
    libreria::v2::funzione();      // chiama v2 esplicito
    cout << libreria::nuova_api() << "\n";   // 42

    return 0;
}

#include <iostream>
using namespace std;

namespace fisica {
    struct Vettore { double x, y, z; };

    // Operator definito nello stesso namespace di Vettore
    Vettore operator+(const Vettore &a, const Vettore &b) {
        return {a.x+b.x, a.y+b.y, a.z+b.z};
    }

    ostream &operator<<(ostream &os, const Vettore &v) {
        return os << "(" << v.x << "," << v.y << "," << v.z << ")";
    }

    double norma(const Vettore &v) {
        return sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
    }
}

// swap personalizzato — ADL permette a std::sort, std::swap etc.
// di trovarlo automaticamente
namespace mylib {
    struct Buffer {
        int *dati; int n;
        Buffer(int n) : dati(new int[n]()), n(n) {}
        ~Buffer() { delete[] dati; }
        Buffer(Buffer &&o) noexcept : dati(o.dati), n(o.n) { o.dati=nullptr; }
    };

    // swap trovato da ADL quando si usa std::sort su mylib::Buffer
    void swap(Buffer &a, Buffer &b) noexcept {
        using std::swap;
        swap(a.dati, b.dati);
        swap(a.n,    b.n);
    }
}

int main() {
    fisica::Vettore v1{1,2,3}, v2{4,5,6};

    // ADL: il compilatore cerca operator+ in fisica:: (namespace di v1, v2)
    fisica::Vettore v3 = v1 + v2;  // Trova fisica::operator+

    // ADL: il compilatore cerca operator<< in fisica:: (namespace di v3)
    cout << v3 << "\n";  // Trova fisica::operator<<

    // ADL: cerca norma in fisica::
    cout << "norma: " << norma(v1) << "\n";  // Trova senza qualifica!

    return 0;
}

// ✅ CORRETTO: usa using declaration per nomi specifici
using std::cout;
using std::string;
using std::vector;

// ✅ CORRETTO: using namespace in .cpp (mai in header)
// In file.cpp — OK
using namespace std;

// ❌ SBAGLIATO: using namespace std nei file header
// — contamina chiunque includa il tuo header
// #include "mio_header.h"  // Portato using namespace std!

// ✅ CORRETTO: struttura namespace per progetto grande
namespace myapp {
    namespace core {
        class Engine { /* ... */ };
    }
    namespace ui {
        class Window { /* ... */ };
    }
    namespace utils {
        void log(const std::string &msg);
    }
}

// ✅ CORRETTO: swap idiom
namespace mylib {
    class Widget {
        std::string nome;
        int val;
    public:
        Widget(std::string n, int v) : nome(n), val(v) {}

        // Membro swap
        void swap(Widget &other) noexcept {
            std::swap(nome, other.nome);
            std::swap(val,  other.val);
        }

        // Operatore di assegnamento con copy-and-swap idiom
        Widget &operator=(Widget other) noexcept {
            swap(other);
            return *this;
        }
    };

    // Free function swap (trovata da ADL)
    inline void swap(Widget &a, Widget &b) noexcept { a.swap(b); }
}

int main() {
    using namespace myapp;
    mylib::Widget w1{"alpha", 1}, w2{"beta", 2};
    using std::swap;
    swap(w1, w2);  // ADL trova mylib::swap
    return 0;
}