C++ Namespaces Beheersen: Functieconflicten Vermijden

Stel je voor dat er in een klas twee personen heten Zara. Om ze te onderscheiden, heb je extra informatie nodig: hun woonplaats, oudersnamen, etc.

Hetzelfde probleem speelt in C++. Je schrijft een functie xyz(), maar een bibliotheek die je gebruikt heeft ook een xyz(). De compiler weet niet welke je bedoelt.

Een namespace lost dit op door extra context te bieden om gelijknamige functies, klassen of variabelen uit verschillende bibliotheken te scheiden. Een namespace definieert een bereik (scope).

Een Namespace Definiëren

Een namespace-definitie begint met het sleutelwoord namespace gevolgd door de naam:

namespace naam_van_namespace {
    // code declaraties
}

Om een functie of variabele uit een namespace aan te roepen, voeg je de naam toe met de scope-resolution-operator :::

naam::code; // code kan variabele of functie zijn

Voorbeeld: Namespaces scheiden entiteiten

#include <iostream>
using namespace std;

namespace first_space {
    void func() { cout << "Inside first_space" << endl; }
}

namespace second_space {
    void func() { cout << "Inside second_space" << endl; }
}

int main() {
    first_space::func();
    second_space::func();
    return 0;
}

Uitvoer:

Inside first_space
Inside second_space

De using-directive

Met using namespace hoef je de namespace-prefix niet telkens te herhalen. De compiler gaat ervan uit dat de volgende code namen uit die namespace gebruikt:

using namespace first_space;

int main() {
    func(); // Roept first_space::func() aan
    return 0;
}

Je kunt ook één specifiek element importeren:

using std::cout;

Nu kan cout zonder prefix gebruikt worden, maar std::endl nog wel.

Voorbeeld: using std::cout

#include <iostream>
using std::cout;

int main() {
    cout << "std::endl wordt met std gebruikt!" << std::endl;
    return 0;
}

Uitvoer:

std::endl wordt met std gebruikt!

Namen uit een using-directive volgen normale scoping-regels: zichtbaar vanaf de directive tot het einde van de scope. Gelijkende namen in een buitenste scope worden verborgen.

Discontiguë Namespaces

Een namespace kan in meerdere delen gedefinieerd worden, verdeeld over verschillende bestanden. De delen vormen samen één namespace. Als een deel een naam nodig heeft die in een ander bestand gedefinieerd is, moet die nog steeds gedeclareerd worden. Het herhalen van de definitie voegt elementen toe aan de bestaande namespace.

Geneste Namespaces

Namespaces kunnen genest worden:

namespace naam1 {
    // declaraties
    namespace naam2 {
        // declaraties
    }
}

Toegang tot geneste members:

using namespace naam1::naam2; // toegang tot naam2
using namespace naam1;         // toegang tot naam1 (en dus ook naam2)

Voorbeeld: Geneste namespaces

#include <iostream>
using namespace std;

namespace first_space {
    void func() { cout << "Inside first_space" << endl; }
    namespace second_space {
        void func() { cout << "Inside second_space" << endl; }
    }
}

using namespace first_space::second_space;

int main() {
    func(); // Roept second_space::func() aan
    return 0;
}

Uitvoer:

Inside second_space