Polymorphes clone ist einfach, wie aber (polymorph) assignen?

[CppBert (Gast)]

Polymorphes clone ist einfach, wie aber (polymorph) assignen?

Info:
-Das ist ein stark simplifiziertes Beispiel - minimal Konstruktor damit 
mal von was von "Aussen" reinkommt (normalerweise viel komplexer)
-Ich kann das nicht statisch realisieren weil ich Basis-Klassen-Zeiger 
von einer Factory bekommen
-die behavior-Methode ist einfach nur ein Aktion die ich per 
Basis-Klassen Zeiger aufrufen kann (normalerweise mehr davon und 
komplexer)
-Ich clone polymorph mit einem Basis-Klassen Zeiger
-Original und Clone sind vom selben Typ - aber eben nur als 
Basis-Klassen Zeiger greifbar
-In meinem Echt-Bespiel sind es noch schlimmere Komposits auf vielen 
verscheidenen Basis-Klassen Zeigern (Ideen von hier sind aber wohl 
anwendbar)
-Für die Hetzjäger unter euch - Nein!, es ist keine Hausaufgabe :)

Ziel: ich möchte auf den polymorphen clone verändern und wieder auf das 
original zurückschreiben

Ideen:
-dynamic-cast geht nicht weil ich nur die Basis-Zeiger habe
-Ich könnte mit dem Visitor Pattern arbeiten - aber ist das 
zielführend/schön

Hat jemand noch ein paar nette (typesafe, ohne wildes ge-caste usw.) 
Ideen?

#include <iostream>

struct Base
{
  int common = 0;
  
  Base(int common):common(common)
  {
  }
    
  // das "operative" Interface meiner Ableitungen
  virtual void behavior() = 0;
  
  // polymorph clonen
  virtual Base* clone() = 0;
  
  // nur als Debug-Hilfe
  virtual void info()
  {
     std::cout << "Base int common: " << common << std::endl;;
  }
};

struct TypeA: Base
{
  TypeA(int common, int value):Base(common),value(value){}
  
  int value = 0;
  virtual void behavior() 
  { 
    common += 2;
    value *= 2; 
  };
  virtual Base* clone() { return new TypeA(*this); }

  virtual void info() 
  {
    Base::info();
    std::cout << "TypeA int value: " << value << std::endl;;
  }
};

struct TypeB: Base
{
  TypeB(int common, double value):Base(common),value(value){}

  double value = 0.0;
  virtual void behavior() 
  { 
    common += 2;
    value *= 2.0; 
  };
  virtual Base* clone() { return new TypeB(*this); }

  virtual void info() 
  {
    Base::info();
    std::cout << "TypeB double value: " << value << std::endl;;
  }
};

void CloneAndReassigne(Base* original)
{
  std::cout << "CloneAndReassigne" << std::endl;
  Base* clone = original->clone();
  std::cout << "Original:" << std::endl;
  original->info();
  clone->behavior();
  std::cout << "Clone nach Aenderung:" << std::endl;
  clone->info();
  *original = *clone;
  std::cout << "Original nach Aenderung:" << std::endl;
  original->info();
}

int main()
{
  TypeA a(1, 2);
  TypeB b(2, 4);
  
  CloneAndReassigne(&a);
  CloneAndReassigne(&b);
}

Zum Online Kompilieren/Spielen: https://onlinegdb.com/HJkWlge14

Ausgabe:

Mit den Problemen die ich klarerweise habe

CloneAndReassigne
Original:
Base int common: 1
TypeA int value: 2
Clone nach Aenderung:
Base int common: 3
TypeA int value: 4
Original nach Aenderung:
Base int common: 3
TypeA int value: 2 <-- nicht Basis-Klassen-Member wurde nicht veraendert

CloneAndReassigne
Original:
Base int common: 2
TypeB double value: 4
Clone nach Aenderung:
Base int common: 4
TypeB double value: 8
Original nach Aenderung:
Base int common: 4
TypeB double value: 4 <-- nicht Basis-Klassen-Member wurde nicht 
veraendert

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

CppBert schrieb:
> Polymorphes clone ist einfach, wie aber (polymorph) assignen?
>
> Hat jemand noch ein paar nette (typesafe, ohne wildes ge-caste usw.)
> Ideen?

Verfrachte die polymorphen Typen einfach in Implementierungsklassen und 
lasse die Klassen, die das Interface zum Nutzer darstellen einfach nur 
noch aus einem Zeig auf die Basis der Implementierungsklassen zeigen. 
Wenn Du std::shared_ptr<> verwendest, bekommst Du die Zuweisungen frei 
Haus geliefert.

Du must nur darauf achten, dass Du evtl. deep copies machen musst, wenn 
Du ein Objekt änderst. Beispiel dafür findest Du z.B hier: 
:https://github.com/TorstenRobitzki/Sioux/blob/master/source/json/json.h

mfg Torsten

[Tom (Gast)]

Die Basis-Klasse als Wert zu behandeln wie hier

*original = *clone;

 führt zu Slicing: https://en.wikipedia.org/wiki/Object_slicing
Minimalinvasive Idee: https://onlinegdb.com/Sy7XuZeJE

[CppBert (Gast)]

Torsten R. schrieb:
> Verfrachte die polymorphen Typen einfach in Implementierungsklassen und
> lasse die Klassen, die das Interface zum Nutzer darstellen einfach nur
> noch aus einem Zeig auf die Basis der Implementierungsklassen zeigen.
> Wenn Du std::shared_ptr<> verwendest, bekommst Du die Zuweisungen frei
> Haus geliefert.

Hört sich gut an - leider kann ich deinen Ausführungen nicht folgen, 
auch dein Beispiel bringt mich gerade nicht weiter

Kannst du es bitte (noch) ein bisschen konkreter beschreiben?

[CppBert (Gast)]

Tom schrieb:
> Die Basis-Klasse als Wert zu behandeln wie hier*original = *clone; führt
> zu Slicing: https://en.wikipedia.org/wiki/Object_slicing
> Minimalinvasive Idee: https://onlinegdb.com/Sy7XuZeJE

Zuerst dachte ich - Wow super Idee, aber es gibt leider andere 
Komponenten die auf das Original per Pointer verweisen

...und vielleicht muss ich in Zukunft auch nur die durch behavior() 
veränderten Teile ersetzen - also wäre ein gezieltes Assign wohl doch 
irgendwie besser, trotzdem super Idee

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

CppBert schrieb:
> Torsten R. schrieb:

> Kannst du es bitte (noch) ein bisschen konkreter beschreiben?

Hier Dein Beispiel:

#include <iostream>
#include <memory>

class Base
{
public:
  Base() = delete;

  void behavior()
  {
    impl_->behavior();
  }

  void info() const
  {
    impl_->info();
  }

protected:
  struct Impl {
    int common;

    explicit Impl(int c) : common(c) {}

    virtual void behavior() = 0;
    virtual void info() const {
      std::cout << "Base int common: " << common << std::endl;
    }

    virtual ~Impl() {}
  };

  explicit Base(const std::shared_ptr< Impl > p) : impl_(p) {}

  std::shared_ptr< Impl > impl_;
};

struct TypeA: Base
{
  TypeA(int common, int value) : Base( std::make_shared< ImplA >( common, value ) ) {}

private:

  struct ImplA : Impl {

    ImplA(int c, int v)
      : Impl( c )
      , value( v )
    {
    }

    void behavior() override
    {
      common += 2;
      value *= 2;
    }

    void info() const override
    {
      Base::Impl::info();
      std::cout << "TypeA int value: " << value << std::endl;;
    }

    int value;
  };

};


struct TypeB: Base
{
  TypeB(int common, double value) : Base( std::make_shared< ImplB >( common, value ) ) {}

private:

  struct ImplB : Impl {

    ImplB(int c, double v)
      : Impl( c )
      , value( v )
    {
    }

    void behavior() override
    {
      common += 2;
      value *= 2;
    };

    void info() const override
    {
      Base::Impl::info();
      std::cout << "TypeB double value: " << value << std::endl;;
    }

    double value;
  };

};

void CloneAndReassigne(Base& original)
{
  std::cout << "CloneAndReassigne" << std::endl;
  Base clone = original;
  std::cout << "Original:" << std::endl;
  original.info();
  clone.behavior();
  std::cout << "Clone nach Aenderung:" << std::endl;
  clone.info();
  original = clone;
  std::cout << "Original nach Aenderung:" << std::endl;
  original.info();
}

int main()
{
  TypeA a(1, 2);
  TypeB b(2, 4);

  CloneAndReassigne(a);
  CloneAndReassigne(b);
}

Das polymorphe Verhalten bekommst Du in den von Base::Impl abgeleiteten 
Klasse. Die von Base abgeleiteten Klassen fungieren eigentlich nur noch 
als factories. Das ganze hat dann value Semantik und polymorphes 
Verhalten, ohne dass Zeiger an der Schnittstelle genutzt werden müssen.

[CppBert (Gast)]

@Torsten R.

Auf jeden Fall ein nettes Konzept - aber es hat mir viel zu starke 
Auswirkungen auf meine Gesamtarchitektur (Impl, Shared-Pointer, alle 
werden zu Value-Types), sonst aber interessant

Ich habe jetzt meine Clone Routine so veraendert das sie nicht einfach 
eine Kopie liefert sondern einen FeedbackClone - der eine virtuelle 
Feedback() anbietet die man dazu nutzen kann den Clone wieder in das 
Original "einzuprägen" - das Konzept ist leider immer noch nicht 
wirklich sauber von meinen "Arbeitsklassen" getrennt aber eine 
ausreichend kleine konzeptionell sehr lokale Lösung

Danke für eure Ideen - wie immer sehr Informativ hier

[tictactoe (Gast)]

CppBert schrieb:
> -dynamic-cast geht nicht weil ich nur die Basis-Zeiger habe

CppBert schrieb:
> *original = *clone;

Man könnte das schon mit einem virtual copy-assignment machen:

class Base {
public:
   virtual Base& operator=(const Base& src) = 0;
...
};

struct TypeA: Base
{
   TypeA& operator=(const TypeA&) = default;
   TypeA& operator=(const Base& src) override   // Gimmick: covariant!
   {
      if (auto src1 = dynamic_cast<const TypeA*>(&src))
         *this = *src1;
      else
         Base::operator=(src);  // Achtung! Slicing!
      return *this;
   }
   ...
};

Alternativen:
- Auf die Kovarianz kannst du verzichten, wenn du sie nicht brauchst.
- Wenn du garantieren kannst, dass die Zuweisung zur Laufzeit nur mit 
kompatiblen Objekten geschieht, kannst du den dynamic_cast mit 
Referenzen machen und auf den else-Zweig verzichten (dann kommt eben 
eine Exception, sollten die Typen mal doch  nicht passen).

Gegen das Slicing im else-Zweig kann man nichts machen. Soll man 
wahrscheinlich aber auch nicht, denn was soll sonst die Bedeutung einer 
Zuweisung von X an Y sein, wenn deren Bestandteile nur teilweise 
übereinstimmen?

[tictactoe (Gast)]

tictactoe schrieb:
> class Base
> {
> public:
>    virtual Base& operator=(const Base& src) = 0;
> ...
> };

Das sollte besser sein:

class Base 
{
public:
   virtual Base& operator=(const Base& src) = default;
...
};