Zugriff auf Container Klasse.

[netraxo]

Hallo,

ich habe ein Problem mit dem Zugriff auf Container.
Fürs Verständnis wäre es wahrscheinlich das beste ihr würdet das Beispiel kurz überfliegen. Hoffe es ist nicht zu viel - sorry.

Ich benutze vier Klassen. Drei Klassen besitzen einen Container (map), welcher die vorherige Klasse darin abspeichert.

Beispiel:

// Grundklasse
class Element
{
    private:
        string name, weitere_infos, ...
        double preis,...
    public:
        // .. Methode zum setzen der Variablen
        void setElement(string name, string weitere_infos, double preis, ...);
        // weitere get-Methoden zum auslesen der Daten
        ...
};

// Klasse in der alle Elemente (class Element) gespeichert werden
Class Elements
{
    private:
        typedef map<string, Element> ElementMap;
        // ... Iterator setzen etc....
        ElementMap ElemMap;
    public:
        bool addElement(string name, string weitere_infos, double preis, ...)
        {
            // neues Element anlegen
            Element NewElement;
            NewElement.setElement(name, weitere_infos, preis, ...);

            // Neues Element in Container einfügen
            return ElemMap.insert(ElementVT(name, NewElement)).second;
        };

        // Methode zum Zugriff auf ein Element aus dem Container
        void getElement(string element_name)
        {
            ElementIt it = ElemMap.find(element_name);
            if (it == ElemMap.end())
                cout<< "There is no element with this name!";
            else
                cout<< "(" << element_name << ")\t" << (*it).second.getElementInfos() << "\t" << (*it).second.getElementPrice();
        };
        ...
};

// Klasse MaterialCompound defniert die chem. Zusammensetzung
// eines Materials aus verschiedenen Elementen
// diese Infos werden auch in einem Map Container abgeleget
class MaterialCompound :: public Elements
{
    private:
        typedef map<string, double> MaterialCompoundMap;
        // ... Iterator setzen etc....
        MaterialCompoundMap MatComMap;
...
}

// Oberklasse Materials speichert alle Materialien in einem Contaier
class Materials :: public MaterialCompound
{
    private:
        typedef map<string, MaterialCompound> MaterialsMap;
        // ... Iterator setzen etc....
        MaterialsMap MatMap;
    public:
        // Methode zum Hinzufügen eines einzelnen Materials in den Container
        bool addMaterial(const MaterialsVT& mat)
        {
            return MatMap.insert(mat).second;
        };

        // !!! Methode die auf die Methode getElement der Klasse Elements zugreift
        void listCompound()
        {
            ...
            this->getElement("string...");
        };
        ...
};

In meinem Hauptprogramm kann ich jetzt wunderbar die Klassen bzw Container befüllen: (Hinweis: die methoden wurde "nach unten" vererbt!)

int main()
{
        // Hier wird der Container der Klasse Elements gefüllt
	Materials materials;
	materials.addElement("Al","Aluminium",5.5f);
	materials.addElement("C","Carbon",7.7);
	materials.addElement("Fe","Eisen",999.99);

        // Hier werden zwei Objekte der Klasse MaterialCompound angelegt und
        // die Zusammensetzungen gespeichert
	Materials material1;
	material1.setMaterialName("Ti64");
	material1.setCompound("Al",6.125);
	material1.setCompound("C",0.875);
	material1.setCompound("Ti",90.0);
	material1.setCompound("Fe",3.0);

	Materials material2;
	material2.setMaterialName("Ti6242");
	material2.setCompound("Fe",5.0);
	material2.setCompound("Al",40.0);
	material2.setCompound("Ti",55.0);

        // Die Beiden Materialzusammensetzungen werden in der Klasse Materials
        // im Container gespeichert
	materials.addMaterial(make_pair(material1.getMaterialName(),material1));
	materials.addMaterial(make_pair(material2.getMaterialName(),material2));
	materials.addMaterial(make_pair(material3.getMaterialName(),material3));

    ...

    // Direkter Zugriff auf den Elements Container:
    materials.getElement("Name");  // das geht :-)

    // Indirekter Zugriff über methode listCompound()
    material1.listCompound();  // geht nicht :-(
};

Problem:
Die Klasse Elements verfügt über die Methode "getElement" zur Ausgabe eines Elements. Rufe ich dies methode direkt aus dem Main Programm auf, erhalte ich die Werte.

Wird diese Methode jedoch "indirekt" über eine andere Klasse aufgerufen, ist der Contaner ElementMap irgendiwe leer und es wird nichts ausgegeben.

Warum ist das so? Hat es was mit den Konstruktoren bzw Destruktoren zu tun?
Oder sind die maps nicht untereinander für andere Klassen verfügbar?

Hoffe ich hab das Problem einigermaße erklärt.

Danke Oliver

[Chemie Fan]

Hi

Kommt mir seltsam vor, deine Vererbung.
Warum erbt MaterialCompound von Elements?
Und warum erbt Materials von Compounds?
Die Beziehung wäre eine "hat eine", also nur der Container.
Mein Vorschlag:

// Oberklasse Materials speichert alle Materialien in einem Contaier
class Materials
{
    private:
        typedef map<string, MaterialCompound> MaterialsMap;
        typedef MaterialsMap::Iterator        MaterialsIter;
        MaterialsMap MatMap;
    public:
        // Methode zum Hinzufügen eines einzelnen Materials in den Container
        bool addMaterial(string name, const MaterialCompound& mat)
        {
            return MatMap.insert( std::make_pair( name, mat );
        };

        // !!! Methode die auf die Methode getElement der Klasse Elements zugreift
        void listCompound()
        {
            for( MaterialsIter it = MatMap.begin(); it != MatMap.end(); ++it )
            {
                it->second->getElement(it->first);
            }
        };
        ...
};

ODer sonst hab ich nicht verstanden, was du machen willst..