die assignment funktionalität einer klasse soll in eine
facade ausgelagert werden, die ihrerseits wiederum auf
einen zentralen handler zugreift, der sich um das asign-
ment von irgendwelchen klassen kümmert.

als erstes mal wieder eine dummy klasse :

class dummy : public asgn_facade<dummy>{
public:
   dummy();
};

jetzt die asgn_facade

template <typename base_t>
struct asgn_facade{
   inline typename asgn_handler<base_t&,const base_t&>::result_type
   operator=(const base_t& rhs){
       return asgn_handler<base_t&,const base_t&>::make(
          *static_cast<base_t*>(this),rhs);
   }

   template <typename rhs_t>
   inline typename asgn_handler<base_t&,const rhs_t&>::result_type
   operator=(const rhs_t& rhs){
        return asgn_handler<base_t&,const rhs_t&>::make(
           *static_cast<base_t*>(this),rhs);
   }
};

wie man sieht lenkt die facade den zugriff auf die assignment operatoren
nur auf den asgn_handler um, deswegen jetzt der asgn_handler, dabei inter-
essiert aber die konkrete implementierung nicht :

template <typename,typename>
struct asgn_handler;

template <>
struct asgn_handler<dummy&,const dummy&>{
   typedef dummy& result_type;

   static inline result_type
   make(dummy&,const dummy&);
};

template <typename rhs_t>
struct asgn_handler<dummy&,const rhs_t&>{
   typedef dummy& result_type;

   static inline result_type
   make(dummy&,const rhs_t&);
};

;

eigentlich sollte jetzt jede art von assignment der klasse dummy über die
asgn_facade umgeleitet werden auf den zugehörigen asgn_handler. das funk-
tioniert für normales assignment auch, d.h.

dummy d1, d2;
d1 = d2; // funzt

für den general assignment operator ist er aber nicht in der lage das
ganze aufzulösen, sondern findet nur den normalen assignment operator :

d1 = 1; // -> compile-time-error

was mich zu der frage bringt, ob assignment operatoren analog zu kon-
struktoren, die funktionalitäts elemente einer klasse sind, die man
leider nicht in eine facade auslagern kann.

was mich dabei aber wundert : man kann z.b. den operator+= in eine
plus_asgn_facade auslagern, ohne das es probleme gibt.

danke, ingo.

So im allgemeinen gesehen könntest du das Problem mal ohne Template beschreiben..

Hmm wenn du deine Frage für den Ottonormalentwickler verständlich ausdrücken würdest könnte man auch Verstehen was du willst...

So im allgemeinen gesehen könntest du das Problem mal ohne Template beschreiben..

Das Problem bei der Sache ist, dass man die templates braucht, da man
ansonsten das curious-recurring-template pattern nicht verwenden kann,
dass man für die facade jeweils braucht. man kann natürlich den
asgn_handler weglassen, dann wirds etwas einfacher.

egal, hab mich damit abgefunden, dass assignment als auf konstruktoren
die einzigen elemente einer klasse sind, die sich nicht in verallgemeinerte
facades auslagern lassen, dann muss man wohl leider immer das assignment
schreiben, obwohl es redundanter code ist.