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