Bonsoir, j'ai une question assez particulières aux connaisseurs.

D'abord le contexte:
J'ai une classe de base abstraite et deux classes (avec template) qui dérivent de cette dernière.
Disons B<typename T> la classes de base, D1<typename T> et D2<typename T> les deux classes dérivées de B. Bon en faite on s'en fout qu'il y ait deux classes dérivées, donc considérons juste D1. Là ce que je cherche à faire c'est de pouvoir surcharger l'opérateur d'assignation afin qu'on puisse par exemple écrire un truc de ce style là.

D<int> V=D<int>(5);
D<float> V2=D<float> (5.15);
V=V2; // appel à l'opérateur d'assignation

Quelqu'un peut-il me dire si il est possible de faire une telle chose?

Merci d'avance!

oui, tu peux faire ca. Tu as deux facon de faire ca. La premiere utilise deux type template. La definition generale est:

template<typename T1, typename T2>
D<T1>& operator= (D<T1>&, const D<T2>&);

Et tu peux faire un traitement general. Peut etre qu'il te faut specialiser les type template et le je ne suis plus completement sure de la syntaxe (j'ecris de memoire).

L'autre solution est de ne pas faire une fonction template generale, mais de faire une fonction non template directement poru les type que tu veux supporter (si tu ne souhaite pas que n'importe quel D<foo> puisse etre assigner un D<bar>). Et tu fais classiquement.

D<int>& operator= (D<int>& a, const D<float> & b);

Ok, je vois ce tu veux dire, godrik, en faite si c'était possible, je préférerai éviter de rajouter un paramètre de template, mais finalement, c'est peut-être la seule solution potable à mon problème merci!

Ta deuxième solution ne me convient pas parceque j'essaye de faire en sorte que ça puisse être n'importe quel "foo" assigner à n'importe quel "bar" (avec quelques restrictions quand même).

Bah en fait tu n'as pas d'autre choix que de rajouter un autre parametre template. Ta fonction operator= admet deux parametres qui ont des type template different.