3. Verschiedene Klassen speichern und wiedergeben

Verschiedene Klassen speichern und wiedergeben

  • S

    Mein prof hat mir heute ein dummes blatt gegeben mit so einer echt dummen formulieren mit der man kaum was anfangen kann.

    leider hat das mich nun irgendwie aus dem konzept gebracht es "elegant" zu lösen.
    eine teilaufgabe ist verschiedene klassen also z.b.

    class a{};
class b: public a{};
class c: public a{};

    im programm "festhalten" (wie ist nicht gegeben, liegt mir frei)
    um die wieder auszugeben. sein tipp: zwei arrays und anschließend nacheinander ausgeben...

    wie würdet ihr diese dynamisch anlegen um diese später wieder auszugeben ?
    mittels rtti ?

    0
  • V

    Also wenn die Aufgabe so wenig Infos enthält, wie dein Beitrag, dann kann ich deine Verwirrtheit nachvollziehen 😉

    Du sollst wirklich Klassen festhalten? Oder vielleicht doch Objekte?
    Objekte zu speichern ist ja kein Problem, da kommt es dann aber einfach darauf an, was mit diesen gemacht werden soll.

    Wenn jetzt aber gemeint ist, dass man die Klassennamen ausgeben soll, gibt es einmal die Möglichkeit der RTTI oder eigene virtuelle Methoden mit den Klassennamen zu schreiben. Dazu gibt es aber parallel noch einen Thread.

    Edit: Einen Punkt habe ich noch vegessen: wenn es um die Zuordnung von string->Klasse geht um zB Instanzen zu erzeugen, dann bietet sich eine Map mit aus strings und Callback-Funktionen an, die die konkreten Instanzen erzeugen.

    0
  • F

    Zeig doch mal die Originalaufgabenstellung.

    0
  • S

    mit festhalten meint er z.b. einen array dynamisch allokierten speicher (ein Objekt) zuweisen

    nochmal aber besser (war vorhin in eile):

    es gibt 3 Klassen davon ist eine die Basisklasse.
    demnach habe ich 2 abgeleitete klassen. meine frage ist:
    wie kann ich diese zwei objekte elegant in einem array unterbringen bzw. STL

    meine Lösungen sind meiner Ansicht nach schlecht und ich probiere hier auch wenig angaben zu machen

    0
  • L

    Ich glaube Du hast da selbst noch ein Verständnisproblem. Du sagst in einem Satz Du hast zwei abgeleitete Klassen, und im nächsten fragst Du wo Du "die zwei Objekte" unterbringen kannst. Ja, welche Objekte? Du hast bisher nur Klassen.

    Mal ein Ansatz (Stichwort polymorphe Zeiger)

    vector<a*> daten;

b B1;
b B2;
c C1;
c C2;

daten.push_back(&B1);
daten.push_back(&C1); // jetzt liegen in dem vector je ein b- und ein c-Objekt
daten.push_back(&B2);
daten.push_back(&C2); // und jetzt je zwei

    Die Objekte darfst Du natürlich auch mit new anlegen und in den vector schieben (damit hast Du aber zusätzlichen Aufräumaufwand).

    Dann die Ausgabe: Du kannst Klassen oder Objekte nicht ausgeben, sondern nur ein Datum daraus. Meint Dein Prof vielleicht, dass Du in a eine virtuelle Funktion anlegen und diese in b und c angemessen überschreiben sollst?

    Auch hier ein Ansatz:

    class a {
public:
    const char* myname() const = 0;
};

/* b und c seien Deiner Fantasie überlassen */

/* Wir verwenden den vector von oben */
for (vector<a*>::iterator it = daten.begin(); it != daten.end(); ++it) {
    cout << (*it)->myname() << endl;
}

    Auf die Verwendung von for_each und Ausgabeiteratoren wurde bewusst verzichtet!

    EDIT:
    Über "zwei Arrays" bin ich erst jetzt gestolpert. Meint er vielleicht etwas dermassen banales?

    a array1[54];
b array2[5];

    😕

    0
  • S

    LordJaxom schrieb:

    EDIT:
    Über "zwei Arrays" bin ich erst jetzt gestolpert. Meint er vielleicht etwas dermassen banales?

    a array1[54];
b array2[5];

    😕

    der prof is bissel lahm, daher wollte ich nach einer guten aber nicht zu guten lösung ausschau halten.

    Der prof macht im prinzip immer solche aufgaben die man erstmal schlecht programmieren sollte und dann im nächsten schritt die verbesserung.

    z.b. sagt der wir sollen eine elementenfkt schreiben die diese klasse ausgibt, im nächsten schritt sollen wir den operator überladen

    ostream& operator<<(ostream& stream, CLASS cl)

    bitte fragt nicht, der mann wills so 😉

    aber im prinzip denk ich mal "der kann mich ...." ich gebe ihm halt das prog mit der STL ab 😉 oder was meint ihr ?

    0
  • W

    Hallo Stelfer,

    vielleicht meint er sowas:

    #include <algorithm>
#include <iostream>

class A
{
public:
    virtual ~A()= 0 {}
    virtual void print( std::ostream& out ) const = 0;

    friend std::ostream& operator<<( std::ostream& out, const A& a )
    {
        a.print( out );
        return out;
    }
};

class B : public A
{
public:
    explicit B( int val = 0 ) : m_val( val ) {}
    virtual void print( std::ostream& out ) const
    {
        out << "B " << m_val;
    }
private:
    int m_val;
};

class C : public A
{
public:
    explicit C( double val = 0 ) : m_val( val ) {}
    virtual void print( std::ostream& out ) const
    {
        out << "C " << m_val;
    }
private:
    double m_val;
};

void printA( const A* a )
{
    std::cout << "> " << *a << std::endl;
}

void delA( A* a )
{
    delete a;
}

int main ()
{
    using namespace std;

    vector< A* > aa;
    aa.push_back( new B( 27 ) );
    aa.push_back( new C( 1.23 ) );
    aa.push_back( new B( -3 ) );

    for_each( aa.begin(), aa.end(), &printA );

    // -- aufräumen
    for_each( aa.begin(), aa.end(), &delA );
    return 0;
}

    Der Output wäre:

    > B 27
> C 1.23
> B -3

    Zu empfehlen ist hier natürlich std::vector< boost::shared_ptr< A > > statt std::vector< A* >, dann spart man sich das aufräumen.

    Gruß
    Werner

    0
Anmelden zum Antworten