Einführung von Namespace in Klassen

area2051

Hallo Forum,

ich soll ein Project das aus mehreren Klassen und vererbte Klassen mit Namespaces versehen.
Habe etwas Literatur gewälzt, jedoch noch kein klares Vorgehen erkannt.

- Soll der namespace in den headerfiles (oder/ und?) in den sources geschehen?
- geschieht die einführen der Namespaces innerhalb der klasse? oder außerhalb?

Im Moment würde ich nur die sources mit

namespace NAME{...}

versehen.
Meint ihr das wäre so richtig?
Lieber erstmal diskutieren als alles coden und dann funktioniert es nicht

Vielen Dank jetzt schon für eure Antworten.
Links zu ausführlich beschriebenen Anleitungen /Erläuterungen würden mir auch schon reichen...

Viele Grüße
Mark

akari

Hallo

Soll der namespace in den headerfiles (oder/ und?) in den sources geschehen?

Alles was in Namespaces soll muß vollständig sein. hast du also die Definition und die Implementation einer Klasse auf zwei Dateien aufgeteilt, must du auch den Namespace sowohl im Header als auch in der Implementationsdatei einrichten. Dabei ist es kein Problem den Namespace mehrmals zu verwenden :

// Headerdatei
namespace ns
{
  class myclass
  {
    int foo();
  };
}

// Implementationsdatei
namespace ns
{
  int myclass::foo()
  {
    return 0;
  }
}

geschieht die einführen der Namespaces innerhalb der klasse? oder außerhalb?

außerhalb, siehe Beispiel.

bis bald
akari

area2051

muss ich zwangsweise sowohl in definition als auch deklaration mit namespaces arbeiten?

hustbaer

area2051 schrieb:

muss ich zwangsweise sowohl in definition als auch deklaration mit namespaces arbeiten?

Ja, natürlich. Sonst hätte der Namespace ja auch keinen Sinn.
Namespaces sind ja dazu da name clashes zu vermeiden, also muss auch überall wo man was deklariert und/oder definiert ganz genau klar sein um welchen Namespace es geht.

Sonst könnte ich ja z.B. nicht 2 Klassen NS1::FOO und NS2::FOO haben, wenn ich für die Definition z.B. nur "FOO::FOO() {}" schreibe.

area2051

nur ein theoretischer Ansatz, weshalb ich mich da schwer tu:
Wenn ich in den Headerfiles meine Klassen und deren Funktionen und Attribute aufliste und die einem Namespace zuweise, dann düfte doch die Definition wissen, woher sie kommt. A) durch die Klassenzuweisung durch den Namespace.
Wenn also in dem headerfile:
namespace Name{
class test{
void funktion1();
};
}
schreibe,
dann dürfte doch im source
#include headerfile
void test::funktion1()
{
//etc
}
doch alles klar sein, oder nicht?
Also ich muss definitiv sowohl header als auch sourcefile mit namespace "Umschreiben" ?

LordJaxom

Wenn Du das im Source so schreibst definierst Du aber nicht die Methode Name::test::funktion1, sondern die Methode ::test::funktion1, und das sind zwei unterschiedliche paar Schuhe. Deshalb gibt es Namespaces doch überhaupt.

area2051

aha, aha, so langsam kommt der Stein ins Rollen.
Werde erstmal ne Nacht drüber schlafen und morgen es versuchen zu implementieren.
ggf. meld ich mich noch, daher lass ich den thread mal noch offen.
Vielen Dank für die zahlreichen und kreativen Antworten!
MfG
Mark

DrakoXP

du kannst es aber auch anders machen,
in der Header schreibst du so:

namespace Bar {
    void foo();
};

und in der Quelldatei das:

void Bar::foo() {
    // Hier Funktionscode
}

das geht auch

DrakoXP

für Klassen sieht das ähnlich aus:

// Header

namespace TheNamespace {
    class TheClass {
        TheClass();
        virtual ~TheClass();
    };
};

// Quellcode (*.cpp)

TheNamespace::TheClass::TheClass() {
}

TheNamespace::TheClass::~TheClass() {
}

ist also ganz einfach

area2051

DrakoXP schrieb:

für Klassen sieht das ähnlich aus:

// Header

namespace TheNamespace {
    class TheClass {
        TheClass();
        virtual ~TheClass();
    };
};

// Quellcode (*.cpp)

TheNamespace::TheClass::TheClass() {
}

TheNamespace::TheClass::~TheClass() {
}

ist also ganz einfach

bisher dachte ich, es wäre einfach ^^...

geht denn im Quellcode auch mit namespace z.B.:
TheNamespace{
TheClass::TheClass()
{//construct}
TheClass::~TheClass()
{//destr. my prog}
}
oder nur so wie du oben geschrieben hast mit TheNamespace::TheClass::TheClass()?

Knecht

area2051 schrieb:

DrakoXP schrieb:
für Klassen sieht das ähnlich aus:
// Header

namespace TheNamespace {
    class TheClass {
        TheClass();
        virtual ~TheClass();
    };
};

// Quellcode (*.cpp)

TheNamespace::TheClass::TheClass() {
}

TheNamespace::TheClass::~TheClass() {
}
ist also ganz einfach
bisher dachte ich, es wäre einfach ^^...

geht denn im Quellcode auch mit namespace z.B.:
TheNamespace{
TheClass::TheClass()
{//construct}
TheClass::~TheClass()
{//destr. my prog}
}
oder nur so wie du oben geschrieben hast mit TheNamespace::TheClass::TheClass()?

Beides ist möglich. Was übersichtlicher ist musst Du von Fall zu Fall unterscheiden.