problem mit vererbung ..

habe zwei klassen A und B wobei B von A erbt (public vererbt). Nun habe ich
Funktion deren deklaration sagt dass sie ein A Objekt als Parameter erwartet.
Ich kann ihr dann also auch ein B geben, weil ein B auch ein A ist.

Nur mein Compiler will es nicht schlucken ...

PS: genauer erwartet meine funktion einen vector<A *> ich gebe ihm vector<B *>
muesste doch funzen!?!??!

danke

Bashar

Nein, vector<A*> ist keine Basisklasse von vector<B*>. Wenn das so wäre, könnte man folgendes machen:

class A { ... };
class B: public A { ... };
class C: public A { ... };
void f(vector<A*>& a) {
  a.push_back(new C);
}
int main() {
  vector<B*> v;
  f(v);
  // ups, f.front() ist kein B*
}

was wuerdet ihr denn dann empfehlen als loesung meine ich?

ich moechte der obigen funktion einen vektor von objekten der Basisklasse uebergeben und die funktionalitaet der funktion durch polymorphie auch
auf fuer die unterklassen moeglich machen.

Also wenn Klasse A eine methode A.doIt() hat und B von A erbt und gleichzeitig
doIt durch B.doIt ueberschrieben wird, was muss ich dann machen damit die obige
funktion alle doIt() Aufrufe aufruft egal ob vector<A *> oder vector<B *>
uebergeben wird!?!?

Danke nochmals

ich glaub ich habs nicht gut genug beschrieben. Situation ist folgende

class A {doIt(){cout "A"}};
class B : public A {doIt(){cout "B"}};

void f(vector<A *> &v){
   ... 
   durch vector rasen und fuer alle objekte darin doIt() aufrufen 
   ...
}

wie schaffe ich obiges !?!?

danke

Con*n

Hi,

Nur kurz zur Polymorphie.

wenn Du vor die Methode einer Klasse virtual schreibst:

class A
{
   public:
    virtual void doIt(){
                             std::cout << "Klasse A\n";
                       }
};

und von dieser Klasse dann eine Klasse ableitest:

class B : public A
{
   public:
    virtual void doIt(){
                             std::cout << "Die Abgeleitete Klasse B";
                       }
};

und dann zwei Zeiger auf A erstellst und jeweils A und B erzeugst:

A *testA = new A;
A *testB = new B;

dann legt den Compiler intern eine Tabelle an: die vtable, aus der er sich dann im Bedarfsfall die richtige Methode holt.

testA->doIt();
testB->doIt();

ergibt :

Klasse A
Die Abgeleitete Klasse B

obwohl ja eigentlich zwei Zeiger auf A vorhanden sind.

ergo, must Du gar nicht wissen, was in Deinem Vector gespeichert ist, sondern Du rufst es einfach auf.

std::vector <A*> tmp;
tmp.push_back(new A);
tmp.push_back(new B);

foo(tmp);

// bla bla
void foo(std::vector<A*> &vec)
{
      vec[liste ablaufen]->doIt();
}

grüße Con@n