Inhalt eines Namespaces nach außen verstecken

Computer: Software & Programmierung C/C++
1

Hi, folgende Frage:

Ich arbeite grad an einer eigenen Spiele-Engine, zumindest versuch ich es :grin:

Bis jetzt ist es so dass ich alles in Namespaces gegliedert habe, die sich jeweils über mehrere Header-Dateien erstrecken.
Es gibt den globalen Namespace, der alle anderen Namespaces für Audio, 3D-Grafik usw. enthält.

Gibt es eine Möglichkeit, einzelne Methoden und Variablen so zu definieren, dass sie innerhalb des globalen Namespaces sichtbar, und verwendbar sind. Nach außen hin aber unsichtbar?

Nach dem folgenden Beispiel:

namespace Engine
{
    int Engine_Version;
    
    void starte_Engine();

    namespace Audio
    {
        starte_Engine();       // funktioniert
        Engine_Version = 1;    // funktioniert ebenfalls
    }
}

using namespace Engine;

starte_Engine();       // funktioniert
Engine_Version = 1;    // funktioniert nicht, Variable ist im besten 
                       // Fall nicht mal sichtbar

Vielleicht hat jemand eine Idee, danke schon mal im Vorraus,

Gruß

2

Hi,

das ist von der Formulierung her ein Ding der Unmöglichkeit.

Allerdings lässt sich das von dir vermutlich Gewünschte mit einem anonymous namespace lösen.

Mach einen

namespace
{

}

innerhalb deines Namespaces auf und füge dort die „nur lokal“ verfügbaren Sachen ein.

Danach berichtest du uns, ob das zu deinem Wohlwollen funktioniert hat, oder anderenfalls beschreibst du genauer, was du haben möchtest.

Gruß
HH

3

Hi, danke für die Antwort.

Das mit den anonymen Namespaces hab ich probiert, macht aber keinen Unterschied.
Vielleicht liegts daran dass ich mit Visual Studio 2015 und entsprechend die .NET Erweiterung verwende,
und nicht das „normale“ C++. Keine Ahnung.

Ich versuch meine Frage ein wenig genauer zu erklären.

Bei einer Klasse zum Beispiel kann man auch mit den Schlüsselwörtern private und public festlegen,
welche Klassen-Elemente von außen, zum Beispiel über eine Instanz der Klasse, aufrufbar sind. Und was nach außen hin unsichtbar ist, und nur von den Elementen in der Klasse selbst erreichbar ist.

class Meine_Klasse
{
    private:
        int Zahl1;        // Zugriff von außerhalb der Klasse nicht möglich
    public:
        int Zahl2;        // Zugriff von außen möglich
}

Im Prinzip möchte ich das selbe erreichen, nur nicht in Form einer Klasse, sondern eines Namespaces.

Gruß
Andreas

4

Hi,

du sagst also, dass bei gegebenem x.h

namespace HUGO
{
    struct X
    {
        int a;
    };
}

und gegebenem x.cpp

#include <iostream>
#include "x.h"

namespace HUGO
{
    namespace 
    {
        int f()
        {
            return 42;
        }

    }
}


main()
{
    std::cout << HUGO::f() << std::endl;
}

bei dir f() auch außerhalb der Übersetzungseinheit x.cpp sichtbar ist?

Gruß
HH

5

Hi, ich hab das nun so probiert wie du geschrieben hast.
Und so funktioniert es auch.

Mein Fehler war, dass ich den anonymen Namespace in x.h definiert habe, und nicht wie du in x.cpp.

Definiere ich ihn in x.cpp ist alles in diesen Namespace nach außen unsichtbar, genau so wie ich es wollte.
Also danke schon mal für die Hilfe.

Ich hab aber gestern Abend noch eine andere Möglichkeit gefunden. Indem ich den ganzen Code der nach außen unsichtbar sein soll, in eine eigene Header-Datei packe, und diese dann in der jeweiligen CPP-Datei, in der er benötigt wird einbinde:

x.h:

namespace Test
{
    Funktion_1();
}

x.cpp:

#include "x.h"
#include "y.h"

namespace Test
{
    Funktion_1()
    {
        std::cout << Unsichtbar::Funktion_2() << std::endl;
    }    
}

y.h:

namespace Unsichtbar
{
    int Funktion_2()
    {
         return 15;
    }
}

main.cpp:

#include <iostream>
#include "x.h"

int main()
{
    Test::Funktion();

    return 0;
}

Trotzdem vielen Dank für deine Hilfe!

Gruß,
Andreas