Ableitungen

Hallo,
ich habe eine Hauptklasse mit virtuellen Methoden

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.

*D*Evil

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

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

finix

Ja, das geht. Hast nur nen kleinen Syntaxfehler drin:

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

otze

(D)Evil schrieb:

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.

*D*Evil

hmm ja stimmt is nen bissel unnötig der cast ... sorry

Danke, für die Bestätigung, bzw Fehlerkorrektur.

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

Kleine Ergänzung: In Bezug auf das oben erwähnte "angestrebte Codedesign" wäre folgender Aufruf das komfortabelste. D.h. dass man bei Benutzung der Operatoren nicht unbedingt auf die entsprechend verwendeten Zeiger achten muss.

// [...]

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

Shinja

Bin mir nicht 100% sicher, aber:

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.

otze

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

  main& operator <<(main* element) {
    element->mach_was();
    return *this;
  }
  //oder alternativ
  template <class obj_t>
  obj_t& operator <<(obj_t * element) {
    element->mach_was();
    return *this;
  }
};

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.