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 ?

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.

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

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];

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 ?

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