template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
On Fri, 23 Nov 2007 08:42:09 -0800 (PST), meow
:template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
La méthode canonique serait plutôt :
class C
{
public:
C& operator+= (C const&);
};
C operator + (C const& a, C const& b)
{
C a;
a+= b;
return a;
}
On Fri, 23 Nov 2007 08:42:09 -0800 (PST), meow
<schwarz.ben@gmail.com>:
template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
La méthode canonique serait plutôt :
class C
{
public:
C& operator+= (C const&);
};
C operator + (C const& a, C const& b)
{
C a;
a+= b;
return a;
}
On Fri, 23 Nov 2007 08:42:09 -0800 (PST), meow
:template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
La méthode canonique serait plutôt :
class C
{
public:
C& operator+= (C const&);
};
C operator + (C const& a, C const& b)
{
C a;
a+= b;
return a;
}
C tmp(a);
tmp += b;
return tmp;
C tmp(a);
tmp += b;
return tmp;
C tmp(a);
tmp += b;
return tmp;
ça a l'air d'etre un problème archi connu et rabaché, mais je n'a i
pas trouvé la réponse ni sur la toile ni sur cette mailing
(probablement les mauvais mots clefs).
template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
template <class T>
A<T> operator+ (A<T>,A<T>){
}
error: template-id 'operator+<>' does not match any template
declaration
si je retire les vilains <> dans la déclaration friend operator :
warning: friend declaration declares a non-template function
ça a l'air d'etre un problème archi connu et rabaché, mais je n'a i
pas trouvé la réponse ni sur la toile ni sur cette mailing
(probablement les mauvais mots clefs).
template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
template <class T>
A<T> operator+ (A<T>,A<T>){
}
error: template-id 'operator+<>' does not match any template
declaration
si je retire les vilains <> dans la déclaration friend operator :
warning: friend declaration declares a non-template function
ça a l'air d'etre un problème archi connu et rabaché, mais je n'a i
pas trouvé la réponse ni sur la toile ni sur cette mailing
(probablement les mauvais mots clefs).
template <class T>
class A {
friend A<T> operator +<>(A<T>,A<T>);
};
template <class T>
A<T> operator+ (A<T>,A<T>){
}
error: template-id 'operator+<>' does not match any template
declaration
si je retire les vilains <> dans la déclaration friend operator :
warning: friend declaration declares a non-template function
Attention : ici, tu n'as pas déclaré une template comme ami,
mais une fonction non-template.
Selon la norme, je crois ce que tu veux, c'est :
friend A<T> operator+< A< T > >( A< T >, A< T > ) ;
Seulement, dans ce cas-là, il faudrait une declaration du
template de la fonction avant la classe. Quelque chose du
genre :
Pour le cas des operator
arithmetiques binaires, par exemple, je fais quelque chose du
genre :
Le template de classe ArithmeticOperators s'occupe de générer un
operator+ (en tant que fonction libre) à partir de l'operator+=.
Plus généralement, dans les templates de classe, j'implémente
toutes les fonctionnalités par des fonctions membres, puis je me
sers de l'idiome de Barton et Nackman pour en générer des
fonctions libres, si j'en ai besoin. Si, par exemple, pour une
raison ou une autre (peut-être des questions de performance), je
ne voulais pas implémenter operator+ au moyen de l'operator+=,
je ferais quelque chose du genre :
template< typename T >
class A
{
public:
A add( A const& other ) const ;
friend A operator+( A const& lhs, A const& rhs )
{
return lhs.add( rhs ) ;
}
} ;
Est-ce que tu aurais un exemple du cas où tu as
l'avertissement ? Je m'y attendrais éventuellement pour ce que
tu as écrit ci-dessus.
Attention : ici, tu n'as pas déclaré une template comme ami,
mais une fonction non-template.
Selon la norme, je crois ce que tu veux, c'est :
friend A<T> operator+< A< T > >( A< T >, A< T > ) ;
Seulement, dans ce cas-là, il faudrait une declaration du
template de la fonction avant la classe. Quelque chose du
genre :
Pour le cas des operator
arithmetiques binaires, par exemple, je fais quelque chose du
genre :
Le template de classe ArithmeticOperators s'occupe de générer un
operator+ (en tant que fonction libre) à partir de l'operator+=.
Plus généralement, dans les templates de classe, j'implémente
toutes les fonctionnalités par des fonctions membres, puis je me
sers de l'idiome de Barton et Nackman pour en générer des
fonctions libres, si j'en ai besoin. Si, par exemple, pour une
raison ou une autre (peut-être des questions de performance), je
ne voulais pas implémenter operator+ au moyen de l'operator+=,
je ferais quelque chose du genre :
template< typename T >
class A
{
public:
A add( A const& other ) const ;
friend A operator+( A const& lhs, A const& rhs )
{
return lhs.add( rhs ) ;
}
} ;
Est-ce que tu aurais un exemple du cas où tu as
l'avertissement ? Je m'y attendrais éventuellement pour ce que
tu as écrit ci-dessus.
Attention : ici, tu n'as pas déclaré une template comme ami,
mais une fonction non-template.
Selon la norme, je crois ce que tu veux, c'est :
friend A<T> operator+< A< T > >( A< T >, A< T > ) ;
Seulement, dans ce cas-là, il faudrait une declaration du
template de la fonction avant la classe. Quelque chose du
genre :
Pour le cas des operator
arithmetiques binaires, par exemple, je fais quelque chose du
genre :
Le template de classe ArithmeticOperators s'occupe de générer un
operator+ (en tant que fonction libre) à partir de l'operator+=.
Plus généralement, dans les templates de classe, j'implémente
toutes les fonctionnalités par des fonctions membres, puis je me
sers de l'idiome de Barton et Nackman pour en générer des
fonctions libres, si j'en ai besoin. Si, par exemple, pour une
raison ou une autre (peut-être des questions de performance), je
ne voulais pas implémenter operator+ au moyen de l'operator+=,
je ferais quelque chose du genre :
template< typename T >
class A
{
public:
A add( A const& other ) const ;
friend A operator+( A const& lhs, A const& rhs )
{
return lhs.add( rhs ) ;
}
} ;
Est-ce que tu aurais un exemple du cas où tu as
l'avertissement ? Je m'y attendrais éventuellement pour ce que
tu as écrit ci-dessus.
@Fabien, c'est essentiellement l'emploi du template qui complique
tout
@Fabien, c'est essentiellement l'emploi du template qui complique
tout
@Fabien, c'est essentiellement l'emploi du template qui complique
tout
Il m'avait semblé que le problème venait du mélange de "friend" et d e
templates. C'est pourquoi je t'indiquais que dans le cas que tu
présentes, on n'utilise généralement pas friend, ce qui devrait
résoudre ton problème.
Il m'avait semblé que le problème venait du mélange de "friend" et d e
templates. C'est pourquoi je t'indiquais que dans le cas que tu
présentes, on n'utilise généralement pas friend, ce qui devrait
résoudre ton problème.
Il m'avait semblé que le problème venait du mélange de "friend" et d e
templates. C'est pourquoi je t'indiquais que dans le cas que tu
présentes, on n'utilise généralement pas friend, ce qui devrait
résoudre ton problème.
template< typename T >
class A : public ArithmeticOperators< A< T > >
{
public
A& operator+=( A const& other ) ;
// ...
} ;
template< typename T >
class A : public ArithmeticOperators< A< T > >
{
public
A& operator+=( A const& other ) ;
// ...
} ;
template< typename T >
class A : public ArithmeticOperators< A< T > >
{
public
A& operator+=( A const& other ) ;
// ...
} ;
(et du coups je me
demande meme pourquoi ces fonctions sont déclarées amies), sauf pour
certains comme ==, !=, << où des champs privés sont accédés :/
(et du coups je me
demande meme pourquoi ces fonctions sont déclarées amies), sauf pour
certains comme ==, !=, << où des champs privés sont accédés :/
(et du coups je me
demande meme pourquoi ces fonctions sont déclarées amies), sauf pour
certains comme ==, !=, << où des champs privés sont accédés :/
Dans le post de Kanze :
Dans le post de Kanze :
Dans le post de Kanze :