C++: Wieso funktioniert hier dynamic binding nicht?

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • C++: Wieso funktioniert hier dynamic binding nicht?

    Habe hier folgendes Stückchen Code:

    Quellcode

    1. Plot p2("overlay");
    3. int EPN = 3;
    4. double ep[] = {5e-2, 1e-2, 1e-3};
    6. for (int i = 0; i < EPN; i++) {
    7. double *h = rx.map(f, N);
    8. double *l = rx.map(f, N);
    10. haar(h, N, ep[i]);
    11. dehaar(h, N);
    12. linear(l, N, ep[i]);
    13. delinear(l, N);
    15. Line lh(x,h,N);
    16. Line ll(x,l,N);
    18. p2.add(lh);
    19. p2.add(ll);
    20. }
    22. p2.plot();
    Alles anzeigen


    Plot ist eine Klasse die intern eine Liste von "Plottables" hält. Line ist eine Subklasse von Plottable. Plottable definiert getPlotCommand() woraus dann ein Skript für Gnuplot gebastelt wird. Dieses skript wird in Plot::plot() erstellt und ausgeführt. Im obigen Code wird jetzt aber anstatt Line::getPlotCommand() Plottable::getPlotCommand() ausgeführt was eigentlich nur eine dummy Methode ist weil stl-Listen offensichtlich keine abstrakten Klassen als generic type akzeptieren.
    Wenn ich den loop weglasse und einfach die erste Iteration ausführe klappt alles wunderbar.

    Kann mir da jemand sagen wie ich das schnell löse? Bin hier grad ziemlich am verzweifeln. Habe auch schon versucht in Plot::plot() alles mittels dynamic cast nach Line zu casten, hat aber auch nicht geholfen.
    Gruss Dominik.

  • RE: C++: Wieso funktioniert hier dynamic binding nicht?

    Original von deconceptional
    Habe hier folgendes Stückchen Code:

    Quellcode

    1. Plot p2("overlay");
    3. int EPN = 3;
    4. double ep[] = {5e-2, 1e-2, 1e-3};
    6. for (int i = 0; i < EPN; i++) {
    7. double *h = rx.map(f, N);
    8. double *l = rx.map(f, N);
    10. haar(h, N, ep[i]);
    11. dehaar(h, N);
    12. linear(l, N, ep[i]);
    13. delinear(l, N);
    15. Line lh(x,h,N);
    16. Line ll(x,l,N);
    18. p2.add(lh);
    19. p2.add(ll);
    20. }
    22. p2.plot();
    Alles anzeigen


    Plot ist eine Klasse die intern eine Liste von "Plottables" hält. Line ist eine Subklasse von Plottable. Plottable definiert getPlotCommand() woraus dann ein Skript für Gnuplot gebastelt wird. Dieses skript wird in Plot::plot() erstellt und ausgeführt. Im obigen Code wird jetzt aber anstatt Line::getPlotCommand() Plottable::getPlotCommand() ausgeführt was eigentlich nur eine dummy Methode ist weil stl-Listen offensichtlich keine abstrakten Klassen als generic type akzeptieren.
    Wenn ich den loop weglasse und einfach die erste Iteration ausführe klappt alles wunderbar.

    Kann mir da jemand sagen wie ich das schnell löse? Bin hier grad ziemlich am verzweifeln. Habe auch schon versucht in Plot::plot() alles mittels dynamic cast nach Line zu casten, hat aber auch nicht geholfen.


    Den Code den Du zeigst hat mit dem was du schreibst aber nicht wirklich was zu tun oder??
    Ich sehe keine Methode die getPlotCommand heißt. Auch sehe ich keinen Iterator sondern ne einfache for-Schleife, ich sehe auch kein loop. Wenn du die Methoden wie oben gesagt schon virtual anlegst sollte das funktionieren (vtable).

    BTW hat dein Problem mit STL überhaupt nix zu tun

  • RE: C++: Wieso funktioniert hier dynamic binding nicht?

    Plot beinhaltet eine Liste (list<Plottable*> anstatt list<Plottable> <- das STL Problem). Über diese Liste wird in Plot::plot() iteriert und für jedes Element das entsprechende Kommando abgefragt (virtual Plottable::plotCommand() oder so ;) ).

    Mein Problem ist das es in C++ offensichtlich einen unterschied macht ob ich

    Quellcode

    1. Line l(...);
    2. p.add(l);
    3. p.plot();

    oder

    Quellcode

    1. for (...) {
    2. Line l(...);
    3. p.add(l);
    4. }
    5. p.plot();

    schreibe.

    Bei ersterem funktioniert dynamic binding, beim zweiten nicht... was läuft da schief?
    Gruss Dominik.

  • RE: C++: Wieso funktioniert hier dynamic binding nicht?

    Original von deconceptional
    Plot beinhaltet eine Liste (list<Plottable*> anstatt list<Plottable> <- das STL Problem). Über

    Warum machst Du das auch so, ergibt doch überhaupt kein Sinn. Du machst ja beim speichern ein "echtes" Plottable Objekt daraus.

    Es ist ein Wunder, dass es überhaupt funktioniert. Dass es in einem Fall klappt, erscheint mir eher zufällig.
    ♥C++

  • Poste bitte mal die Signatur von Plot::add().
    getPlotCommand muss auf jeden Fall virtuell sein, und Plot::add muss entweder einen Zeiger oder eine Referenz auf eine Plottable-Instanz bekommen. Da Du Line wahrscheinlich per value übergibst, läuft grundsätzlich was falsch (Polymorphismus geht in C++ nur über Zeiger oder Referenzen). Du übergibst die lokale Line-Instanz vom Stack aus der Schleife, nach dem Schleifendurchlauf existiert dieses aber nicht mehr (ich vermute, Du hast keine entspr. Copy-Konstruktoren und einen new-operator für Line geschrieben, die das abfangen).
    Deine Liste sollte auf jeden Fall mit Zeigern auf Plottable-Instanzen arbeiten (geht auch gar nicht anders) und Plottable sollte abstrakt sein.

  • RE: C++: Wieso funktioniert hier dynamic binding nicht?

    Original von zermelo
    Original von deconceptional
    Plot beinhaltet eine Liste (list<Plottable*> anstatt list<Plottable> <- das STL Problem). Über

    Warum machst Du das auch so, ergibt doch überhaupt kein Sinn. Du machst ja beim speichern ein "echtes" Plottable Objekt daraus.

    Es ist ein Wunder, dass es überhaupt funktioniert. Dass es in einem Fall klappt, erscheint mir eher zufällig.


    Ok, ich entnehme daraus das ich mit einer Zuweisung Typ1 var = wasVomTyp2 eine Konvertierung stattfindet?
    Gruss Dominik.

  • Original von SumpfMonster
    Poste bitte mal die Signatur von Plot::add().
    getPlotCommand muss auf jeden Fall virtuell sein, und Plot::add muss entweder einen Zeiger oder eine Referenz auf eine Plottable-Instanz bekommen. Da Du Line wahrscheinlich per value übergibst, läuft grundsätzlich was falsch (Polymorphismus geht in C++ nur über Zeiger oder Referenzen). Du übergibst die lokale Line-Instanz vom Stack aus der Schleife, nach dem Schleifendurchlauf existiert dieses aber nicht mehr (ich vermute, Du hast keine entspr. Copy-Konstruktoren und einen new-operator für Line geschrieben, die das abfangen).
    Deine Liste sollte auf jeden Fall mit Zeigern auf Plottable-Instanzen arbeiten (geht auch gar nicht anders) und Plottable sollte abstrakt sein.


    Ok, jetzt funktioniert das ganze, vorher war Plot::add(Plottable&) und jetzt ist Plot::add(Plottable*) was aber, wenn ich mich gerade richtig informiert habe, keinen Unterschied macht. Was ich nach wie vor nicht verstehe ist, wieso das mit den Variabeln auf dem Stack nicht geht. Ich hab die Linien jetzt mit new alloziert, damit hab ich keine Probleme mehr.
    Gruss Dominik.

  • RE: C++: Wieso funktioniert hier dynamic binding nicht?

    Original von deconceptional
    Ok, ich entnehme daraus das ich mit einer Zuweisung Typ1 var = wasVomTyp2 eine Konvertierung stattfindet?


    Konvertierung muss ja stattfinden, sonst klappt die Zuweisung nicht. Wenn Du nur Zeiger zuweist, ist das nicht problematisch (bei Klassenhierarchien), weisst Du aber direkt die Objekte zu, werden diese implizit umgewandelt, sofern möglich.

    Zur Illustration:

    Quellcode

    1. struct Foo {
    2. int feld1;
    3. };
    4. struct Bar : public Foo {
    5. int feld2;
    6. };
    7. int main(int argc, char* argv[]) {
    8. Bar baz;
    9. baz.feld1 = 666;
    10. baz.feld2 = 999;
    12. Foo foz;
    13. foz = baz;
    14. // wo ist jetzt feld2 gespeichert?
    15. // genau! NIRGENDWO
    17. Bar *b = static_cast<Bar*>(&foz);
    19. // Natuerlich kein Problem:
    20. std::cout << b->feld1 << std::endl;
    21. // Geht schief: feld2 ist UNDEFINIERT
    22. std::cout << b->feld2 << std::endl;
    23. return 0;
    24. }
    Alles anzeigen


    EDIT:
    Achso, das Gegenbeispiel, dass alles mit Pointern kein Problem ist:

    Quellcode

    1. /* Gegenbeispiel */
    2. Foo *spam = &baz;
    3. Bar *eggs = static_cast<Bar*>(spam);
    4. /* nur zeiger geschubbst, das objekt ansich
    5. * ist aber unveraendert geblieben. folglich
    6. * klappt alles: */
    7. std::cout << eggs->feld1 << std::endl;
    8. std::cout << eggs->feld2 << std::endl;
    10. // added comfort: (wer mag schon diese pfeile...)
    11. Bar &eggywags = *static_cast<Bar*>(spam);
    12. std::cout << eggywags.feld1 << std::endl;
    13. std::cout << eggywags.feld2 << std::endl;
    Alles anzeigen
    ♥C++

  • Original von deconceptional
    Ok, jetzt funktioniert das ganze, vorher war Plot::add(Plottable&) und jetzt ist Plot::add(Plottable*) was aber, wenn ich mich gerade richtig informiert habe, keinen Unterschied macht. Was ich nach wie vor nicht verstehe ist, wieso das mit den Variabeln auf dem Stack nicht geht.

    Es geht mit Variablen auf dem Stack, aber dazu muß man einiges beachten. Unter anderem das von zermelo angesprochene Slicing muß man verhindern.

    C-Quellcode

    1. #include <string>
    2. #include <iostream>
    4. class Base {
    5. std::string name_;
    6. public:
    7. Base (std::string name) : name_(name) {}
    8. void virtual print () {
    9. std::cout << this->name_ << "\n";
    10. }
    11. // Abstrakte Klasse, wichtig ist daß er virtuell ist, sonst darf man über
    12. // Basiszeiger keine Objekte löschen.
    13. virtual ~Base() = 0;
    14. };
    16. Base::~Base() {}
    18. class A : public Base {
    19. public:
    20. A () : Base ("Klasse A") {}
    21. ~A() {}
    22. };
    24. class B : public Base {
    25. public:
    26. B () : Base ("Klasse B") {}
    27. ~B() {}
    28. };
    30. int main () {
    31. A a;
    32. B b;
    34. a.print ();
    35. b.print ();
    37. Base* p1(&a);
    38. Base* p2(&b);
    40. p1->print();
    41. p2->print();
    42. }
    Alles anzeigen

    Wichtig ist hierbei, daß alle Methoden virtuell deklariert sein müssen, sonst geht das nicht. Einfaches Überladen reicht nicht aus.

    C-Quellcode

    1. include <string>
    2. #include <iostream>
    4. class Base {
    5. std::string name_;
    6. public:
    7. Base (std::string name) : name_(name) {}
    8. void print () {
    9. std::cout << this->name_ << "\n";
    10. }
    11. virtual ~Base() = 0;
    12. };
    14. Base::~Base() {}
    16. class A : public Base {
    17. public:
    18. A () : Base ("Klasse A") {}
    19. ~A() {}
    20. };
    22. class B : public Base {
    23. public:
    24. B () : Base ("Klasse B") {}
    25. ~B() {}
    26. void print () {
    27. std::cout << "uups\n";
    28. }
    29. };
    31. int main () {
    32. A a;
    33. B b;
    35. a.print ();
    36. b.print ();
    38. Base* p1(&a);
    39. Base* p2(&b);
    41. p1->print();
    42. p2->print();
    43. }
    Alles anzeigen


    Nächster Punkt:
    Alle Container der STL basieren auf Wertsemantik, daher sollte man niemals Objekte über Zeiger oder Referenzen dort ablegen, wenn sie nicht anderweitig verwaltet werden!

    Damit das letzte Beispiel funktioniert brauchst Du boost -> boost.org

    C-Quellcode

    1. include <string>
    2. #include <iostream>
    3. #include <vector>
    4. #include <algorithm>
    5. #include <boost/smart_ptr.hpp>
    7. class Base {
    8. std::string name_;
    9. public:
    10. Base (std::string name) : name_(name) {}
    11. void virtual print () {
    12. std::cout << this->name_ << "\n";
    13. }
    14. virtual ~Base() = 0;
    15. };
    17. Base::~Base() {
    18. std::cout << "Base Destruktor called\n";
    19. }
    21. class A : public Base {
    22. public:
    23. A () : Base ("Klasse A") {}
    24. ~A() {}
    25. };
    27. class B : public Base {
    28. public:
    29. B () : Base ("Klasse B") {}
    30. ~B() {}
    31. };
    33. void print (Base* base) {
    34. base->print();
    35. }
    37. void print_v (boost::shared_ptr<Base> p) {
    38. p->print();
    39. }
    41. int main () {
    42. std::vector<boost::shared_ptr<Base> > v;
    43. std::vector<Base*> vector(2);
    44. {
    45. A a;
    46. B b;
    48. vector[0] = &a;
    49. vector[1] = &b;
    51. std::for_each (vector.begin(), vector.end(), print);
    52. }
    53. // Ab hier darf man nicht mehr die Zeiger in vector nutzen,
    54. // da die Objekte bereits zerstört wurden!
    56. std::cout << "Block eins beendet\n";
    57. {
    58. v.push_back (boost::shared_ptr<Base> (new A));
    59. v.push_back (boost::shared_ptr<Base> (new B));
    60. }
    61. std::for_each (v.begin(), v.end(), print_v);
    63. // so und nun tun wir mal genau das was man nicht tun darf.
    64. std::for_each (vector.begin(), vector.end(), print);
    65. }
    Alles anzeigen