Discussion :

[Razgriz]

Bonjour à tous,

j'essaye de concevoir un template pour une classe A<T> dans lequel je veux implémenter les fonctions suivantes (code minimal détaillé ci-dessous) :

1. un constructeur explicit qui prend un T en paramètre (le fait qu'il soit explicit est important pour mon "vrai" code)
2. un opérateur + (membre) me permettant de faire un + entre un A et un T
3. un opérateur + (indépendant) me permettant de faire un + entre un T et un A

Vous trouverez un code minimal ci-dessous.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <iostream>
 
template<class T> class A;
 
template<class T> std::ostream& operator<<(std::ostream&, const A<T>&);
template<class T> A<T> operator+(const T&, const A<T>&);
 
template<class T>
class A
{
	T i;
	public:
		explicit A(T t) : i(t) {}
 
		A operator +(A<T> a) const
		{
			return A(a.i + i);
		}
 
		A operator +(T t) const 
		{ 
			return A(i + t); 
		}
 
 
		friend std::ostream& operator<< <>(std::ostream& out, const A<T>& a);
		friend A<T> operator+ <>(const T& t, const A<T>& a);		
};
 
template<class T>
std::ostream& operator<<(std::ostream& out, const A<T>& a)
{
	out << a.i;
	return out;
}
 
template<class T>
A<T> operator +(const T& t, const A<T>& a)
{
	return a + t;
}
 
int main()
{
	A<int> b(2);
      	std::cout << (b + 2) << std::endl;
	std::cout << (2 + b) << std::endl;
}

Problème : le compilateur m'envoie balader, en me disant que je déclare un opérateur + comme une "non-function", ce qui est ... exactement ce que je veux faire.
J'ai déclaré une amitié pour cet opérateur de la même manière que pour l'injection << dans les flux, mais a priori, ça ne marche pas.

Évidemment, si j'enlève le '<>' dans la déclaration d'amitié, j'ai un warning me disant que je déclare une fonction non-template, ce qui n'est pas ce que je veux.

Que dois-je faire ? Pour rappel, je ne veux pas concevoir de constructeur non explicit (ce qui me permettrait de faire des conversions implicites d'un T vers un A et je n'aurais pas de problème).

Merci d'avance

[Bousk]

Salut,

bien que n'ayant jamais rencontré de syntaxe aussi alambiquée, la déclaration ne devrait pas être friend template<class T> A<T> operator +(const T& t, const A<T>& a) ou bien template<> A<T> operator +(const T& t, const A<T>& a) ?
Puisque généralement il s'agit d'écrire friend <<prototype>>.

[Razgriz]

Les lignes 5 et 6 sont des déclarations de fonctions templates indépendantes, où il est nécessaire de préciser que T est une classe, ce qui est fait. Il n'y a a priori pas de problèmes sur ces lignes.

La déclaration d'amitié de cette fonction envers la classe A doit néanmoins se faire au sein de A, car c'est une classe qui déclare qui « est son ami », permettant ainsi d'accéder aux attributs privés directement. C'est cette déclaration d'amitié qui est incorrecte pour le compilateur.

Cette syntaxe est celle présente sur cppreference (avant dernier code). Je n'ai toutefois pas une grande expérience en C++, je suis donc aussi assez preneur d'une alternative plus élégante.

[Bousk]

Si je m'en tiens au code de cppreference en l'adaptant j'écrirais friend A operator+ <>(const T& t, const A& a);, ce qui n'est toujours pas ta syntaxe originale.

[Razgriz]

Les <..> sont implicites au sein d'une classe déclarée template : les écrire est redondant, mais pas une erreur. Je les écris pour me rappeler de ce avec quoi je traite. Aussi, les erreurs à la compilation sont exactement les mêmes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
brol.cpp:27:20: error: declaration of ‘operator+’ as non-function
   friend A operator+ <>(const T& t, const A& a);  
                    ^
brol.cpp:27:20: error: expected ‘;’ at end of member declaration
brol.cpp:27:22: error: expected unqualified-id before ‘<’ token
   friend A operator+ <>(const T& t, const A& a);  
                      ^

[jo_link_noir]

Les <..> sont implicites au sein d'une classe déclarée template : les écrire est redondant, mais pas une erreur.

Pas pour une fonction amie qui, même si elle est déclaré dans une classe ne fait pas partie de celle-ci.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template<class U>
friend A<U> operator+ (const U& t, const A<U>& a);