Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!
Werbeanzeige
TigerClaw25
unregistriert
C-/C++-Quelltext |
|
1 2 |
vector<int> vDaten(3); vector<int>::iterator i; |
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 |
class CSpieler{ foo(); }; CRaumschiff::foo(){ //irgendwas } |
Community-Fossil
Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer
(Ich empfehle übrigens die Nicht-Verwendung von "using namespace xy;")
TigerClaw25
unregistriert
"CRaumschiff::m_Zaehler=0" ist schließlich auch kein Namensraum, sondern eine Klasse namens "CRaumschiff".
vector ist ein Namensraum? Ich dachte, dass es sich dabei um eine Klasse, genauer um eine Templateklasse handelt. So interpretiere ich das. Aber eine Templateklasse ist ja kein Namensraum, daher bin ich mit der Aussage etwas verwirrt.
Community-Fossil
Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer
Klar, weil du nur das liest, was du lesen willst und das, was du nicht verstehst, einfach ignorierst. Aber um mal zum Kern der Sache zu kommen: Eine nested Class mit demselben Namen "A" kann in jeder beliebigen Klasse deklariert werden. Einfach nur "A" zu verwenden, wäre für den Compiler also mehrdeutig. Es ist aber eindeutig, wenn die Parent-Class als Namensraum interpretiert wird, denn dann ist ganz klar ein Unterschied zwischen ClassX::A und ClassB::A vorhanden. Dass eine Class nun kein Namespace ist, ist nach den Namen der Begriffe eindeutig. Aber dennoch gibt es natürlich eine sehr sehr offensichtliche Ähnlichkeit zwischen beiden. Sie können nämlich beide eindeutig Variablen und Funktionen enthalten, die es auch in anderen Scopes gibt, ohne dass es zu Konflikten kommt. Und um nun durch diese Scopes zu "navigieren", nutzt du "::".Aber eine Templateklasse ist ja kein Namensraum, daher bin ich mit der Aussage etwas verwirrt.
Und um nun durch diese Scopes zu "navigieren", nutzt du "::".
TigerClaw25
unregistriert
Administrator
C-/C++-Quelltext |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
class Class { public: int instanceMember; static int staticMember; class InnerClass { public: int instanceMember; static int staticMember; }; }; // Definition der statischen Member (Wert ist automatisch 0). int Class::staticMember; int Class::InnerClass::staticMember; int main() { Class.instanceMember = 42; // ? Class.staticMember = 42; // ? Class::instanceMember = 42; // ? Class::staticMember = 42; // ? std::cout << sizeof(Class::instanceMember) << std::endl; // ? std::cout << sizeof(Class::staticMember) << std::endl; // ? Class c1, c2; c1::instanceMember = 42; // ? c1::staticMember = 42; // ? c1.instanceMember = 42; // ? c1.staticMember = 42; // ? c2.staticMember = 43; // ? std::cout << (c1.staticMember == c2.staticMember ? "gleich" : "ungleich") << std::endl; // ? (static_cast<Class*>(nullptr))->staticMember = 42; // ? Class.InnerClass ic1; // ? Class::InnerClass ic2; // ? ic2.staticMember = 42; // ? std::cout << "Wie gross ist Class::InnerClass wohl? Antwort: " << sizeof(Class::InnerClass) << std::endl; // ? InnerClass::staticMember = 42; // ? Class::InnerClass::staticMember = 42; // ? c1::InnerClass ic3; // ? } |
C-/C++-Quelltext
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 int main() { //Class.instanceMember = 42; // Falsch! Der Punkt kann nur bei Instanzen benutzt werden. //Class.staticMember = 42; // s.o. //Class::instanceMember = 42; // Falsch! instanceMember müsste static sein. Class::staticMember = 42; // OK! std::cout << sizeof(Class::instanceMember) << std::endl; // OK, obwohl instanceMember nicht statisch ist! Du fragst hier "Wie groß ist der Member instanceMember einer beliebigen Instanz von Class?", ohne eine Instanz erzeugen zu müssen. std::cout << sizeof(Class::staticMember) << std::endl; // Sowieso OK! Class c1, c2; //c1::instanceMember = 42; // Falsch! Instanzen erzeugen keinen Scope! //c1::staticMember = 42; // s.o. c1.instanceMember = 42; // OK! c1.staticMember = 42; // OK, aber ... c2.staticMember = 43; // ... da staticMember statisch ist, braucht es keine Instanz. std::cout << (c1.staticMember == c2.staticMember ? "gleich" : "ungleich") << std::endl; // OK! Ausgabe ist "gleich"! staticMember ist nicht an Instanzen gebunden. (static_cast<Class*>(nullptr))->staticMember = 42; // Sogar das geht! staticMember ist nicht an Instanzen gebunden. Wohin der Zeiger zeigt, ist völlig egal. //Class.InnerClass ic1; // Falsch! InnerClass ist kein Member von Class, sondern nur im Scope von Class! Class::InnerClass ic2; // OK! ic2.staticMember = 42; // OK! std::cout << "Wie gross ist Class::InnerClass wohl? Antwort: " << sizeof(Class::InnerClass) << std::endl; // OK! staticMember zählt nicht zur Größe dazu, denn sizeof gibt die Größe einer Instanz. //InnerClass::staticMember = 42; // Falsch! InnerClass ist innerhalb von Class und ist von außen nicht sichtbar. Class::InnerClass::staticMember = 42; // OK! //c1::InnerClass ic3; // Falsch! Instanzen erzeugen keinen Scope! }
Werbeanzeige