Iterator zugriff auf abgeleitete Klasse

[helpme91 (Gast)]

Hallo zusammen,

ich bräuchte eure Hilfe.
Ich habe ein C++ Programm in visual studio geschrieben.

Dies sieht folgendermaßen aus:

Ich habe eine Basisklasse + zwei weitere Klassen die von der Basisklasse 
erben.
Funktion alles bereits.

Jetzt gibt es noch eine 4 Klasse, die nichts vererbt bekommt.
Diese soll nur Verwalten.
In dieser Klasse habe ich eine Liste mit Iterator erstellt.
Nun möchte ich mit diesem Iterator auf die Methoden der abgeleiteten 
Klassen zugreifen.
Leider findet der Iterator immer nur Methoden aus der Basisklasse, aber 
nicht aus den beiden abgeleiteten, obwohl die Methoden public sind.

So sieht meine Liste aus:

list <Bestellung*> liste;
list <Bestellung*>::iterator it;

// Hier möchte ich die Methode aufrufen:
(*it)->...Methoden der abgeleiteten Klassen......;

Wie geht das?

[Oliver S. (oliverso)]

helpme91 schrieb:
> Wie geht das?

Ohne cast gar nicht.

Oliver

[helpme91 (Gast)]

Wie kann ich die komplette liste einfach auf der Konsole ausgeben?

[c-hater (Gast)]

helpme91 schrieb:

> // Hier möchte ich die Methode aufrufen:
> (*it)->...Methoden der abgeleiteten Klassen......;
>
> Wie geht das?

Nur mit cast. Was natürlich ein saublöde Lösung wäre, weil dann für alle 
Fälle möglicher Erben verzweigt werden müsste.

Oder anders ausgedrückt: Dein Konzept ist grundfalsch.

[Klaus W. (mfgkw)]

Wenn ich dein Problem richtig verstanden habe, fehlt dir virtual vor den 
Methoden, die du aufgerufen haben willst.

Ohne das virtual kommt der Compiler nicht auf die Idee, in den 
Ableitungen nach einer Methode zu suchen.

// Time-stamp: "18.09.21 18:30 bestellung.cpp [e-mail]"
//
// g++ -Wall --std=c++17 bestellung.cpp -o bestellung && ./bestellung

#include <iostream>
#include <string>
#include <list>


class Bestellung
{
public:
  Bestellung( const std::string &name )
    : name( name )
  {
  }

  virtual void zeigDich()
  {
    std::cout << "ich bin eine Bestellung " << name << std::endl;
  }

protected:
  std::string    name;
};

class Expressbestellung: public Bestellung
{
public:
  Expressbestellung( const std::string & name )
    : Bestellung( name )
  {
  }

  virtual void zeigDich()
  {
    std::cout << "ich bin eine Expressbestellung " << name << std::endl;
  }
};

class Schneckenbestellung: public Bestellung
{
public:
  Schneckenbestellung( const std::string & name )
    : Bestellung( name )
  {
  }

  virtual void zeigDich()
  {
    std::cout << "ich bin eine Schneckenbestellung " << name << std::endl;
  }
};


int main( int nargs, char **args )
{
  std::list< Bestellung* >   meineliste;
  meineliste.push_back( new Bestellung( "per Bote" ) );
  meineliste.push_back( new Expressbestellung( "UPS" ) );
  meineliste.push_back( new Schneckenbestellung( "DHL kommt vielleicht auch irgendwann an" ) );

  for( auto it: meineliste )
  {
    it->zeigDich();
  }
  return 0;
}

Gibt bei mir aus:

klaus@lap7:~$ g++ -Wall --std=c++17 bestellung.cpp -o bestellung && ./bestellung
ich bin eine Bestellung per Bote
ich bin eine Expressbestellung UPS
ich bin eine Schneckenbestellung DHL kommt vielleicht auch irgendwann an

Lasse ich die virtual weg, kommt nur noch:

klaus@lap7:~$ g++ -Wall --std=c++17 bestellung.cpp -o bestellung && ./bestellung
ich bin eine Bestellung per Bote
ich bin eine Bestellung UPS
ich bin eine Bestellung DHL kommt vielleicht auch irgendwann an

Das heißt, es wird ohne virtual immer die Methode aus der Basisklasse 
genommen.

[Klaus W. (mfgkw)]

c-hater schrieb im Beitrag #6824769:
> Letztlich ist es also (wie so oft) ein trade off zwischen Speicherbedarf
> und Rechenzeit, welche der beiden Möglichkeiten man verwendet. Deswegen
> habe ich oben das "richtig" auch in Anführungszeichen gesetzt. Um
> anzudeuten, dass es manchmal durchaus auch richtig (im Sinne von
> "sinnvoll") sein kann, das eigentlich falsche und verpönte zu tun...

Nein, ist es (hier zumindest) absolut nicht.
Der "richtige" Weg ist auch ohne Anführungsstriche der richtige, der 
andere ist Murks.

Hast du doch selbst schon gesagt:

c-hater schrieb:
> Nur mit cast. Was natürlich ein saublöde Lösung wäre, weil dann für alle
> Fälle möglicher Erben verzweigt werden müsste.
>
> Oder anders ausgedrückt: Dein Konzept ist grundfalsch.

Außer dem "Nur" hattest du doch recht. Bleib doch dann auch dabei...

[c-hater (Gast)]

Klaus W. schrieb:

> Nein, ist es (hier zumindest) absolut nicht.
> Der "richtige" Weg ist auch ohne Anführungsstriche der richtige, der
> andere ist Murks.

Das weisst du woher? Also ich jedenfalls bräuchte für diese Entscheidung 
zumindest drei Informationen:

1) Anzahl der Erben-Klassen
2) Anzahl der Objekt-Instanzen
3) Menge des verfügbaren Speichers

Selbst wenn man mal annehmen wollte, dass zumindest Punkt 1 mit dem TO 
erschöpfend behandelt ist, bleiben da doch noch zwei sehr wesentliche 
Punkte...

Also ich würde sowas nicht mit deiner Stringenz entscheiden wollen 
OHNE die Kenntnis dieser Fakten...

Aber was weiss ich schon, ich programmiere ja erst seit 40 Jahren und 
verdiene seit 30 Jahren meinen Lebensunterhalt damit...

Aber ja: vor ca. 30 Jahren hätte ich vielleicht noch genauso 
argumentiert wie du. Da hatte ich ungefähr gerade den OO-Kram wirklich 
verstanden und fand das endlos geil. Aber: man lernt dazu...