leider habe ich in keinen der Bücher/Internet hierzu eine Antwort gefunden. Vielleicht kann mir hier ja wer helfen. Angenommen ich habe eine Klasse Häuser, diese Häuser haben einen Namen...

Initiliasiert wird der Name über den Konstrukter.

class Haeuser
{
private:
static string Name;

public:

Haeuser(string);
~Haeuser(void)

}

Haeuser::Haeuser(string t)
{
Name=t;

 }

string Haeuser::Name="";

Main:

for (int i=0;i<3;i++)
{
Haeuser gelb("neu")
}

Den Namen der Häuser habe ich mit static festgesetzt... legt der in der Main() 1 Mal die Klasse Häuser an oder 3 Mal???
Wenn 3 Mal, wie bekomme ich ihn dazu, dass wenn der Name identisch ist, er die Klasse nicht erneut anlegen soll? Oder muss ich extra nochmal einen Vektor oder so anlegen, welcher sich die angelegten Objekte merkt und dann dort immer suchen obs den Namen schon gibt? Oder überlade ich für die Häuser einfach den operator== ??? Gibt es hierzu vielleicht auch Seiten im Internet, welche empfehlenswert sind?

Dankeschön

Viele Grüße

Jullia

Julia_Prog schrieb:

Den Namen der Häuser habe ich mit static festgesetzt...

Was willst du den damit genau erreichen?

Julia_Prog schrieb:

legt der in der Main() 1 Mal die Klasse Häuser an oder 3 Mal???

Das Objekt wird bei jedem Schleifendurchlauf erstellt und am Ende wieder zerstört. Es existiert also bei jedem Durchlauf ein neues Haus.

Julia_Prog schrieb:

Wenn 3 Mal, wie bekomme ich ihn dazu, dass wenn der Name identisch ist, er die Klasse nicht erneut anlegen soll? Oder muss ich extra nochmal einen Vektor oder so anlegen, welcher sich die angelegten Objekte merkt und dann dort immer suchen obs den Namen schon gibt? Gibt es hierzu vielleicht auch Seiten im Internet, welche empfehlenswert sind?

Schau dir mal eine map an. Das ist ein Schlüssel-Wert-Container, dh. statt einem Index hast du einen beliebigen Schlüssel, mit dem du auf deine Werte zugreifen kannst. Wenn der Schlüssel also schon vorhanden, dann gibt es das Objekt schon.

Natürlich kommen da auch Häuser doppelt vor

Haus1; Haus2; 4
Haus1; Haus3; 2
Haus2; Haus3; 5

und meine Sorge war ja nur, dass wenn er später mit den Distanzen rechnet, dass er auch weiß das Haus1 immer Haus1 ist und ich dachte das ich sonst ja immer eine neue Instanz von Haus1 anlege.

Oder soll ich in der Klasse Haeuser den == Operator überladen? Oder macht das kein Sinn? Meine C++ Anfänger Bücher helfen da nicht weiter

#include <set>
#include <vector>
#include <iostream>

class Haus
{
public:
    Haus(const std::string& name) : 
      name_(name)
    {}
    // benötigt für std::set (weiter unten):
    bool operator<(const Haus& other) const
    {
        return name_ < other.name_;
    }
private:
    std::string name_;
};

struct Entfernung
{
    Entfernung(const Haus& v, const Haus& n, unsigned int entf) :
        von(&v), nach(&n), km(entf)
    {}
    const Haus* von, *nach;
    unsigned int km;
};

class Entfernungen
{
public:
    void Add(const std::string& von, const std::string& nach, unsigned int km)
    {
        const Haus& h1 = *(haeuser_.insert(von).first);  // Haus einfügen, oder das schon bekannte holen
        const Haus& h2 = *(haeuser_.insert(nach).first);  // dito
        entfernungen_.push_back(Entfernung(h1, h2, km));
    }
private:
    std::set<Haus> haeuser_;  // hier sind alle bisher bekannten häuser gespeichert. 
                              // Sie unterscheiden sich durch den Namen
    std::vector<Entfernung> entfernungen_;
};

int main() 
{
    using namespace std;
    Entfernungen e;
    e.Add("haus 1", "haus 2", 4);
    e.Add("haus 1", "haus 3", 2);
    e.Add("haus 2", "haus 3", 1);

    return 0;
}

#include <map>

class Haus
{
    std::string name;   // Hausname
    std::map<std::string, int> distanzen; // Key: Hausname; Value: Distanz
};

Darüber kannst du dann ganz einfach über den Namen die jeweilige Distanz raus suchen lassen.