Conversion implicite et template

11 réponses

Marc Boyer

06/08/2003 à 12:58

J'ai un problème de code qui marche sans template et ne marche pas avec.
C'est un peu long (désolé).

Je tente d'écrire une surcouche à int, Entier, avec conversion
implicite de int->Entier (constructeur), et une surcharge
de l'opérateur binaire +.

Ca marche.

Et si je fait de Entier un template, ça refuse de compiler...
> no match for `Entier<int>& + int' operator

Une idée ?

Merci d'avance.

Marc Boyer
------------- Le code qui marche ---------------
class Entier {
private:
int val;
public:
Entier(int v):val(v){}
Entier& operator+=(const Entier& inc){
val+=inc.val;
return *this;
}
};

Entier operator+(const Entier& left, const Entier& right){
Entier tmp(left);
tmp+= right;
return tmp;
}

int main(){
Entier a=1;
Entier b=1;
b = a + 1;
b = 1 + a;
return 0;
}

------------------------ Le code qui plante -------------------
te <typename T>
class Entier {
private:
T val;
public:
Entier(T v):val(v){}
Entier<T>& operator+=(const Entier<T>& inc){
val+=inc.val;
return *this;
}
};

template <typename T>
Entier<T> operator+(const Entier<T>& left, const Entier<T>& right){
Entier<T> tmp(left);
tmp+= right;
return tmp;
}

int main(){
Entier<int> a=1;
Entier<int> b=1;
b = a + 1;
b = 1 + a;
return 0;
}

--
Lying for having sex or lying for making war? Trust US presidents :-(

1 réponse

1 2

Gabriel Dos Reis

08/08/2003 à 09:54

writes:

| Gabriel Dos Reis wrote in message
| news:...
| > Marc Boyer writes:
|
| > | Gabriel Dos Reis wrote:
| > | > Marc Boyer writes:
|
| > | >| Gabriel Dos Reis wrote:
| > | >| J'ai lu et relu ton message. Je ne comprends pas pourquoi il
| > | >| n'y a plus de déduction d'argument template.
|
| > | > C'est parce que, dns ce cas, pour qu'il y ait déduction d'argument
| > | > de templates, il faut qu'il y a une fonction template. Or il n'y
| > | > en a pas :-).
|
| > | > La fonction amie operator+ (définie dans ArithmeticType<>) et la
| > | > fonction amie add (définie dans Entier<>) ne sont pas des
| > | > fonctions templates.
|
| > | La distinction qui m'avait échappée, c'est qu'une fonction
| > | template n'est pas la même chose qu'une function membre d'une classe
| > | template (ce dont j'aurais pu me souvenir puisque l'une accepte les
| > | spécialisations partielles et pas l'autre), et que les fonctions
| > | amies de classes templates sont encore une troisième chose, c'est ça
| > | ?
|
| > Presque. Les fonctions amies d'une classe template ne sont pas
| > forcément templates. Elles ne sont pas templates juste parce qu'elles
| > sont définies dans une class template. Elles ne sont templates que si
| > leurs déclarations sont précédées de l'entête « template<...> ».
|
| Juste pour voir si j'ai bien compris. Dans le cas d'une fonction
| templatée, l'existance de la fonction dépend de l'induction des
| types.

ou de la vérification des arguments de template lorsque ceux-ci sont
explicitement fournis.

| Dans le cas d'une fonction ami définies dans une classe
| templatée, la fonction existe (ou au moins est déclarée) du moment que
| l'instance de la classe existe.

Tout à fait exact.

1 2

Conversion implicite et template

1 réponse

Veuillez sélectionner un problème