class haupt {
  private:
    std::string was_auch_immer;
  public:
    virtual void test() = 0;
}

von denen mehrere Unterklassen abgeleitet werden

class sub : public haupt {
  public:
    int i;
    void test() { return }
}

Ist es möglich Pointer auf Instanzen von sub in einem Vektor für Pointer auf haupt zu speichern?

sub *abgeleitete_klasse = new sub();
std::vector <class *haupt> moo;
moo.push_back(abgeleitete_klasse);

PS: Ich habe hier gerade leider keinen C++-Compiler zur Hand, würde es sonst in der Praxis testen.

habs auch nicht getestet ... aber sollte doch gehen ...

sub* abgeleitete_klasse = new sub();
std::vector<haupt*> moo;
moo.push_back(abgeleitete_klasse);

sub my_class;
std::vector<haupt*> moo;
moo.push_back(reinterpret_cast<haupt*>(&my_class));

habs auch nicht getestet ... aber sollte doch gehen ...

brauchst keinen reinterpret_cast. von abgeleiteter Klasse zur basisklasse wird automatisch konvertiert. nur runter brauchst du entweder den dynamic_cast oder, wenn du genau weist was du tust, den static_cast.

Wenn ich gerade dabei bin, möchte ich auch noch folgende Frage in den Raum werfen, die mich seit einigen Tagen beschäfftigt:
Folgender (mehr oder weniger) Pseudocode soll mit Hilfe des überladenen <<-Operators eine bestimmte Funktion ausführen, die jedoch in Anbetracht des Fehlers unbedeutend ist - auch eine andersweitige Umsetzung auf Grund des angestrebten Codedesigns ist nicht möglich.

class main {
  public:
  virtual void mach_was() = 0;

  //////////////////////////////
  template <class obj_t>     // obj_r repräsentiert ausschließlich von _main_ abgeleitete Klassen
  obj_t * &operator <<(obj_t * &element) {
    element->mach_was(); // nicht unbedingt von Belang
    return *this;
  }
  //////////////////////////////
};

class foo : public {
  void mach_was();
  // weitere deklarationen
};

class bar : public {
  void mach_was();
  // weitere deklarationen
};

// + weitere klassen, die von main abgeleitet sind

main() {
  foo *foo_elem = new foo;
  bar *bar_elem = new bar;
  bar *bar_elem2 = new bar;

  ////////////////////////////
  *foo_elem << bar_elem << bar_elem2;
  ////////////////////////////
  return 0;
}

Wie schaffe ich, den <<-Operator bei Pointern sinnvoll einzusetzen, sodass obiger Code kompilierbar ist. Die eigentlichen "Problemzonen" sind entsprechend mit "/////" gekennzeichnet.

Danke bereits im voraus,
Marc

// [...]

  ////////////////////////////
  foo_elem << bar_elem << bar_elem2;
  ////////////////////////////
  return 0;
}

soweit ich bisher operator<< gesehen habe nimmt der doch immer 2 Argumente: das was rechts davon steht und das was links davon steht.

Falls ich recht habe heiszt es also:

friend obj_t * &operator <<(main &rechts,obj_t * &element) {
    element->mach_was(); // nicht unbedingt von Belang
    return *this;
  }
  /////

Aber da du scheinbar mehr Ahnung hast von C++ als ich würds mich nicht wundern wenn der Fehler woanders läge.

probier erstmal aus, ob dich das glücklich macht ;). die template lösung würde ich aber nur nutzen, wenn es wichtig ist, dass du ein obj_t zurückbekommst. wenn ein main reicht, dann würde ich auf die templates verzichten

btw: fehlermeldungen sind bei solchen sachen ganz nützlich.