Opérateurs surchargés et héritage et modèles (une combinaison formidable)

problème intéressant. Les modèles et héritage ne se mélangent pas vraiment bien, et puisque vous ne pouvez pas corriger u code> cela fait un défi intéressant à coup sûr.

Je propose d'atténuer le mécanisme de déduction de la surcharge :) P> Le moyen le plus simple serait de fournir une surcharge pour chaque classe code> dérivée code>. Évidemment, il est impraticable. P>

Sauf si nous pouvions utiliser une classe d'assistance pour laquelle l'opérateur est écrit et mélanger Typefs de là pour le rendre transparent pour le client. P>

struct Base {};

template <typename T>
struct BaseT: Base
{
  typedef T Tag;
};

struct DerivedTag {};
typedef BaseT<DerivedTag> Derived;

class Q {};
class U
{
public:
  template< typename Y >
  Q operator * (Y)
  {
    Q r;
    return r;
  }
};

Base operator * (U, const Base &)
{
  Base r;
  return r;
}

template <typename T>
BaseT<T> operator*(U, BaseT<T> const&) { return BaseT<T>(); }

int main(int argc, char **argv)
{
  Base myBase;
  U myU;
  Base myOtherBase = myU * myBase;
  Derived myDerived;
  Derived myOtherDerived =  myU * myDerived;
  return 0;
}

Tout comme j'ai abandonné essayé de résoudre cette dernière nuit, la réponse m'a frappé comme une brique. Le résultat code> q code> de u :: opérateur * (base) code> est conceptuellement identique à la base base code> résultat tapé de opérateur * ( U, base) code>, même si elles sont représentées par différents types. Tout ce que j'ai besoin de faire est de fournir un constructeur pour base (const Q &) code> qui accepte le type Q.

class Base
{
public:
Base(){}
Base(const Q &){}
};