folgender Code kompiliert nicht:

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class A
{
public:
  virtual void ausgabe() const = 0;
};

class B : public A
{
public:
  void ausgabe() const {cout << "Ausgabe Klasse B\n";}
};

class C : public A
{
public:
  void ausgabe() const {cout << "Ausgabe Klasse C\n";}
};

int main()
{
  vector<A> vecA;
  vecA.push_back(B());
  vecA.push_back(C());

  for(int i=0, j=vecA.size(); i<j; ++i)
  {
    vecA.at(i).ausgabe();
  }
}

Die Sache ist klar: Da Klasse A rein virtuell ist kann der Vektor nicht funktionieren.

Mein Problem ist, wie bekomme ich es hin dass:

1. Objekte der Klassen B und C (die eine gemeinsame Basisklasse haben - nämlich A) die Methode ausgabe() von Klasse A überschreiben

UND

2. in ein und demselben Vektor (nämlich vector<A>) landen

UND

3. bei Aufruf der Methode ausgabe() der Objekte im Vektor die korrekte Ausgabe folgt (nämlich "Ausgabe Klasse B" und "Ausgabe Klasse C")

Danke und Gruß

#include <iostream>
#include <string>
#include <vector>

using namespace std;

class A
{
public:
  virtual void ausgabe() const = 0;
};

class B : public A
{
public:
  void ausgabe() const {cout << "Ausgabe Klasse B\n";}
};

class C : public A
{
public:
  void ausgabe() const {cout << "Ausgabe Klasse C\n";}
};

int main()
{
  vector<A*> vecA;
  vecA.push_back(new B());
  vecA.push_back(new C());

  for(int i=0, j=vecA.size(); i<j; ++i)
  {
    vecA.at(i)->ausgabe();
    delete vecA.at(i);
  }
}

Warum?

Das man keine Objekte einer abstrakten Klasse anlegen kann, weißt du ja schon. Gegen Zeiger auf diese Objekte spricht aber an sich nichts. Technisch wird dabei (meistens) ein sogenannter VTable angelegt, der dafür sorgt, dass am Ende die richtigen Methoden ausgerufen werden:
http://de.wikipedia.org/wiki/Tabelle_virtueller_Methoden

OK, mit Pointern funktionierts:
...
Warum?

Vielleicht noch etwas weiterführende Erklärung (kann es sein das du von C# oder Java kommst, die zwar alltäglich Zeiger verwenden, aber es vor dem Programmierer verbergen?):

> ACHTUNG VEREINFACHTE DARSTELLUNG <<<

Wenn du eine Klasse A hast, und eine Klasse B, die von A abgeleitet ist, stellen sich Objekte dieser Typen vereinfacht wie folgt im Speicher dar.

A a;                    B b;
[A spezifischer Teil]   [A spezifischer Teil]
                        [B spezifischer Teil]

Sprich ein Objekt besteht im Speicher aus seinen Teilen, sowie allen Teilen der Klassen von dem es abgeleitet ist. Wenn du nun ein Objekt des Types B einen des Types A zuweist, "schneidest" du Teile ab.

a = b;
[A spezifischer Teil] <== [A spezifischer Teil]
                       x  [B spezifischer Teil] => wird nicht übertragen

Zeiger und Referenzen verhalten sich hier anders, da du hier keine Objekte kopierst. Beide verweisen auf den Objektanfang.

Zeiger und Referenzen verhalten sich hier anders, da du hier keine Objekte kopierst. Beide verweisen auf den Objektanfang.

Ahh...

Besten Dank für alle Antworten.

Zeiger und Referenzen verhalten sich hier anders, da du hier keine Objekte kopierst. Beide verweisen auf den Objektanfang.

Ahh...

Nimm es aber nicht zu wörtlich. Zeiger verweisen tatsächlich auf die Startadresse, Referenzen können - müssen aber nicht - intern Zeiger sein (ggf. werden sie gänzlich wegoptimiert). Wie gesagt ist dies eine vereinfachte Darstellung.

Hm... kann das nicht gefährlich werden? Ich erinnere mich da an:
Richtlinie 3: Behandle Vektoren niemals polymorph.

Nein, damit ist ganz was anderes gemeint. Dabei geht es um die Verwendung von Vektoren einer abgeleiteten Klasse als Vektor einer Basisklasse. Das geht (genauso wie bei Arrays) selbstverständlich schief.

Die Verwendung von Vektoren von Zeigern auf Objekte einer Basisklasse ist aber genau die Art und Weise wie Polymorphie vorgesehen ist.

Die Verwendung von Vektoren von Zeigern auf Objekte einer Basisklasse ist aber genau die Art und Weise wie Polymorphie vorgesehen ist.

...mal abgesehen davon, dass es in Hinblick auf Exceptionsicherheit und automatischer Speicherverwaltung bestimmt bessere Möglichkeiten als rohe, besitzende Zeiger in STL-Containern gibt.