wieder eine C++ Anfängerfrage.

Ich versuche gerade mit dem Handling von Klassen und Objekten zurecht zu kommen und evtl. sogar irgendwann das Konzept "Referenz" zu verstehen.

Ich habe eine Klasse "TadObject" als Basisklasse, die bei der Erzeugung von Instanzen eine "Id" verwaltet. Davon können spezialisiertere Klassen erben können, z.B. TadLocation. Darum geht es aber aktuell nicht.

Jetzt möchte ich eine Kollektion von TadObject verwalten, also Instanzen von TadObject oder Unterklassen erzeugen und dort speichern, suchen, usw. Also tatsächlich sollen dort natürlich Verweise auf die Objekte gespeichert werden. Referenzen, Pointer, ? Wie oben geschrieben blick ich da noch nicht so durch.

Was ich bisher habe, scheint auch zu funktionieren. Ich würde nur gerne wissen, ob das einigermaßen "sauber" implementiert ist oder mir unter Umständen etwas um die Ohren fliegen könnte.

// tadobject.h
class TadObject
{
    public:
        TadObject(const string aName);
        TadObject(const TadObject& aObject);
        virtual ~TadObject();
        int getId();
        string getName();
    private:
        const int id;
        const string name;
        static int nextId;
};

inline int TadObject::getId()
{
    return id;
}

inline string TadObject::getName()
{
    return name;
}

//tadobject.cpp
int TadObject::nextId = 1;

TadObject::TadObject(string aName): id(TadObject::nextId++), name(aName) { }

TadObject::TadObject(const TadObject &aObject) : id(TadObject::nextId++), name(aObject.name) { }

TadObject::~TadObject() { }

//tadcollection.h
class TadCollection
{
    public:
        TadCollection();
        void insert(TadObject& aObject);
        TadObject& at(int aId);
    private:
        std::map<int, TadObject&> items;
};

//tadcollection.cpp
TadCollection::TadCollection() { }

void TadCollection::insert(TadObject& aObject)
{
    items.insert(std::pair<int, TadObject&>(aObject.getId(), aObject));
}

TadObject &TadCollection::at(int aId)
{
    return items.at(aId);
}

//main.cpp
int main(int argc, char *argv[])
{
    TadObject o1("Eins");
    TadObject o2("Zwei");
    TadLocation o3("Drei");
    TadObject o4 = o3;

    cout << o1.getId() << " : " << o1.getName() << endl;
    cout << o2.getId() << " : " << o2.getName() << endl;
    cout << o3.getId() << " : " << o3.getName() << endl;
    cout << o4.getId() << " : " << o4.getName() << endl;
    cout << endl;

    TadCollection collection;
    collection.insert(o1);
    collection.insert(o2);

    cout << collection.at(1).getId() << " : " << collection.at(1).getName() << endl;
    cout << collection.at(2).getId() << " : " << collection.at(2).getName() << endl;

    return 0;
}

Wäre sehr nett, wenn mich der eine oder andere korrigieren könnte und im besten Fall auch kurz erläutert, was das Problem werden könnte.

Danke und Gruß,
temi

int main(int argc, char *argv[])
{
    TadObject o1("Eins");
    TadObject o2("Zwei");
    TadLocation o3("Drei"); // TadLocation mit ctor von TadObject
    TadObject o4 = o3;
    TadLocation o5("Vier", "Du siehst eine große Vier."); // TadLocation mit erweitertem ctor
    TadObject* o6 = new TadObject("Sechs"); // Zeiger auf ein Object

    cout << o1.getId() << " : " << o1.getName() << endl;
    cout << o2.getId() << " : " << o2.getName() << endl;
    cout << o3.getId() << " : " << o3.getName() << endl;
    cout << o4.getId() << " : " << o4.getName() << endl;

    cout << o5.getName() << " : " << o5.getDescription() << endl;

    cout << o6->getId() << " : " << o6->getName() << endl; // Zugriff über "->", wie erwartet
    cout << endl;

    TadCollection collection;
    collection.insert(o1);
    collection.insert(o2);
    collection.insert(o3);
    collection.insert(o4);
    collection.insert(o5);
    collection.insert(*o6); // Zeiger in Collection einfügen
    collection.insert(new TadObject("Sieben")); // Geht nicht!!! ctor übeladen?

    cout << collection.at(1).getId() << " : " << collection.at(1).getName() << endl;
    cout << collection.at(2).getId() << " : " << collection.at(2).getName() << endl;

    cout << collection[3].getId() << " : " << collection[3].getName() << endl;
    cout << collection[6].getId() << " : " << collection[6].getName() << endl; // Zugriff über "." ???
    cout << endl;

    TadObject& r1 = o1; // Referenz auf o1

    // Speicheradressen von o1
    cout << "o1 (Ursprungsklasse): " << &o1 << endl;
    cout << "r1:(Referenz auf o1): " << &r1 << endl;
    cout << "o1 (aus Kollektion) : " << &collection[1] << endl;

    // Speicheradressen von o6
    cout << "o6 (Ursprungsklasse): " << o6 << endl;
    cout << "o6 (aus Kollektion) : " << &collection[6] << endl;

    delete(o6); // Wohin damit?

    return 0;
}

Zuerst hab ich mir mal die Speicheradressen von ein paar Variablen ausgeben lassen. Da z.B. alle Adressen von o1 identisch sind, müsste das mit dem Speichern von Verweisen ja funktionieren. Auch die Adressen des gespeicherten Zeigers o6 sind identisch.

Mittlerweile habe ich auch den operator [] überladen, so dass ein direkter Zugriff über die Id möglich ist.

Beim Zeiger o6 ist zunächst der Zugriff auf Members nur über -> möglich, warum ist das bei dem o6 aus der Kollektion nicht mehr so?

Wer könnte die Verwaltung von o6 (das abschließende delete) übernehmen. Kann ich in der Kollektion irgendwie herausfinden, ob das gespeicherte Objekt mit "delete" freigegeben werden muss? Dann könnte das der dtor von TadCollection übernehmen.

Für das Testen ist die Vorgehensweise mit

TadObject o1("EINS")

und spätere Zuweisung zur Kollektion ja in Ordnung. Soll das mal, z.B. aus einer Datei (Liste von Strings) geschehen, dann müsste das ja in der Art

collection.insert(new TadObject(strAusListe));

passieren. Das geht leider noch nicht!?

Letztes Problem. Wenn ich in der Kollektion eine Unterklasse von TadObject speichere, dann habe ich nach dem Lesen aus der Kollektion keinen Zugriff auf die Member der Unterklasse. Ist ja auch logisch. In C# gab es dafür so etwas wie

collection[3] as TadLocation

Wie geht das in C++??

Danke,
temi

Ein Problem ist zum Beispiel, dass .at() normalerweise es ermöglichen sollte, da ein neues Objekt zuzuweisen, was aber nicht gehen wird. Außerdem ist es viel logischer, wenn du Pointer speicherst - du hast ja gerade keine konkrete Objekte, die du referenzieren willst, sondern "irgendwelche" Objekte.

Dann noch ein paar Bemerkungen:
- in deinen Headern fehlt überall das std:: - ich hoffe, du hast dort kein "using namespace" drin?

- wenn du eine Default-Implementierung machen willst wie bei deinem leeren Destruktor, dann kannst du einfach "virtual ~TadObject() = default;" schreiben.

- ich würde bei getName() eher "const string&" als Rückgabetyp erwarten, denn du brauchst den String ja nicht dauernd zu kopieren.

- Wenn du verschiedene Klassen drin hast in deiner Collection und ein "as" suchst, dann gucke bei "dynamic_cast<DerivedClass*>(pointerToBase)" nach. Allerdings sollte man versuchen, die casts zu vermeiden. Wenn du ausschließlich Derived-Objekte in deinem Container hast, dann template die Container-Klasse so, dass du dort den Typ mit angeben kannst und verzichte auf alle Casts.

- Vermeide explizites "new" und "delete"! Nimm stattdessen smart_pointer.

Kann ich in der Kollektion irgendwie herausfinden, ob das gespeicherte Objekt mit "delete" freigegeben werden muss? Dann könnte das der dtor von TadCollection übernehmen.

Nein. Daher: entweder, du speicherst smart pointer in deinem Container. Dann geht alles automatisch - und zu zeigst an, dass dem Container die Objekte gehören. Oder du speicherst normale pointer. Das zeigt normalerweise an, dass der Container keine Ownership hat und die anderswo behandelt wird. (wie im Vorpost gesagt, bei Qt-Objekten ist das ggf. anders)
Wie man es machen sollte, erklärt z.B. folgendes Video gut: https://www.youtube.com/watch?v=JfmTagWcqoE

mit Referenzen in Containern kommst du schnell in die Hölle, tu das nicht und nimm stattdessen Pointer.

Irgendwie ist mir der Unterschied noch nicht so klar, für mich stellen beide "Referenzen" dar. Vielleicht dieser? Eine Referenz referenziert auf ein konkretes Objekt. Ein Zeiger referenziert auf die Adresse eines Objektes. Was aber irgendwie wieder identisch ist, weil beides über die Adresse funktioniert und auch beim Zeiger das Objekt im Speicher erzeugt wurde, also konkret vorhanden ist. Und wann nutze ich dann was?

ich hoffe, du hast dort kein "using namespace" drin?

Ähem, ja hab ich. Schlecht? Warum?

ich würde bei getName() eher "const string&" als Rückgabetyp erwarten

Ist das der richtige Einsatz von Referenzen? Ist das const dabei obligatorisch? Was ist der Unterschied zwischen:

const string& getName()

und

string& getName()

Da waren jetzt sicher auch blöde Fragen dabei, aber manche Dinge in C++ machen es mit ganz schön schwer. Ich muss jetzt leider hier Schluss machen, weil wir gleich zu einem feuchtfröhlichem Feierabend losziehen. Ich bin aber sicher, dass ich morgen noch weitere Fragen haben werden, falls euch das nicht stört.

Gruß,
temi

Irgendwie ist mir der Unterschied noch nicht so klar, für mich stellen beide "Referenzen" dar.

Eine Referenz ist ein anderer Name für ein Objekt. Unterschiede sind z.B., dass du einem Pointer auch nullptr zuweisen kannst (zeigt auf nichts) - Referenz auf nichts gibt es nicht! Und auch: einer Pointervariablen kannst du einen Wert zuweisen, d.h. sie nachträglich auf andere Variablen zeigen lassen. Eine Referenz initialisierst du einmalig und nicht wieder!

Also

int i,j;
int *p = &i;
p = &j; // ok, p zeigt nun auf j
int &r = i; 
r = j; //weist i den Wert von j zu, r bleibt weiterhin Ref auf i

Und sogar sizeof(referenz) gibt dir die Größe des referenzierten Objektes, nicht die der Referenz!

Daher müsste man Referenzen nochmal verpacken, um sie in Container zu legen, siehe z.B. http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper

ich hoffe, du hast dort kein "using namespace" drin?

Ähem, ja hab ich. Schlecht? Warum?

Sollte hoffentlich in jedem C++-Buch stehen. Wenn du das machst, wird automatisch in jeder Datei, die den Header included, das "using namespace std" drin sein! Header sollten aber nur Klassen/Funktionssignaturen zur Verfüfung stellen, nicht automatisch meine Namespaces ändern. Ansonsten zwingst du das "using namespace" jedem auf, der deinen Header benutzen möchte.

ich würde bei getName() eher "const string&" als Rückgabetyp erwarten

Ist das der richtige Einsatz von Referenzen? Ist das const dabei obligatorisch? Was ist der Unterschied zwischen:

const string& getName()

und

string& getName()

Klar ist das richtig. Was erwartest du von "getName"?
- soll einfach sein (d.h. nicht unnötig kopieren)
- soll das Objekt nicht ändern

Daher lautet die Funktion vollständig:

const string& TadObject::getName() const {
    return name;
}

Beachte: 2x const! Das hintere sagt dir, dass getName das Objekt nicht ändert.
Wenn du nur string& getName() hast, dann könnte Code von außen Namen ändern:

TadObject o1("Eins"); 
o1.getName() = "Zwei";

bzw. das würde nicht compilieren, da du ja "const string name" als Membervariable hast. Da das const ist, kannst du nicht einfach string& returnen, denn das würde sich ja widersprechen.
-> error: invalid initialization of reference of type ‘std::string& {aka std::basic_string<char>&}’ from expression of type ‘const string {aka const std::basic_string<char>}’

Im Gegensatz zu Java sind strings in C++ nicht immutable!

Eine Zuweisung der Art

string name = o1.getName()

geht natürlich weiterhin, denn hier würde jetzt das ganze String-Objekt kopiert und damit wirst du das const los.

Wenn du das machst, wird automatisch in jeder Datei, die den Header included, das "using namespace std" drin sein

Das stimmt. Es war nicht ganz leicht es zu finden, aber es steht tatsächlich auch in meinem Buch.

Danke für die ausführliche Erklärung zur Rückgabe von Referenzen. Mir war in Beispielen auch schon die inflationäre Verwendung von "const" aufgefallen ohne eine rechte Erklärung dafür zu finden.

Jetzt verbessere ich erst mal meine Klassen, dann seh ich weiter.

Schönen Sonntag,
temi