friend & espaces de nommage

Version imprimable

Hello,

J'ai défini un opérateur binaire * comme suit (il ne fait pas grand chose pour l'instant, j'en suis conscient) :
Code:

1 2 3 4 5 6 7 8 9 10 template <class T1, template<class> class StorageT1, class T2, template<class> class StorageT2> Matrix<T1, StorageT1> operator*(const Matrix<T1, StorageT1>& matrix1, const Matrix<T2, StorageT2>& matrix2) { Matrix<T1, StorageT1> outMatrix(matrix1.nbRows, matrix2.nbColumns); return outMatrix; }
Lorsque je crée 3 matrices (qui sont accessoirement exactement du même type), et que je fais :

Code:

matrice3 = matrice1* matrice2;

J'obtiens l'erreur :

Code:

ambiguous overload for ‘operator*’

Exemple compilable si possible. Je ne vois pas de probleme a priori et n'en ai pas avec:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
template <typename T> struct Storage;
 
template <typename T, template <typename> class S>
struct Matrix {};
 
template <class T1, template<class> class StorageT1,
          class T2, template<class> class StorageT2>
Matrix<T1, StorageT1>
operator*(const Matrix<T1, StorageT1>& matrix1, const Matrix<T2, StorageT2>& matrix2)
{
    Matrix<T1, StorageT1> outMatrix;
 
    return outMatrix;
}
 
int main()
{
    Matrix<int, Storage> m1, m2, m3;
    m3 = m1*m2;
    return 0;
}

Alors en fait, ça semble venir du fait que la classe Matrix est en fait définie dans un espace de nommage, que l'opérateur soit défini en dehors de tout espace de nommage, et que l'opérateur * soit défini comme friend dans la classe Matrix.

Je précise que dans le bout de code que j'avais donné, j'avais, pour des raisons de lisibilité, enlevé les références à l'espace de nommage précédent le nom de la classe Matrix.

Quand j'enlève la déclaration friend, ça compile, mais ça m'ennuie, car je n'ai plus accès aux données internes de la matrice.

Apparemment, le compilateur ne fait pas le lien entre la déclaration hors de l'espace de nommage (celle que je vous ai présentée), et la déclaration friend. Il les voit comme deux surcharges différentes, et en déduit une ambiguïté. J'ai essayé, dans la déclaration friend, de rajouter l'opérateur de portée ::
Code:

1 2 3 4 template <class T1, template<class> class StorageT1, class T2, template<class> class StorageT2> friend Matrix<T1, StorageT1> ::operator*(const Matrix<T1, StorageT1>& matrix1, const Matrix<T2, StorageT2>& matrix2);
mais j'obtiens l'erreur :

Code:

ISO C++ forbids declaration of ‘operator*’ with no type

EDIT : en fait, mon problème ressemble assez à celui-ci. J'essaye de mettre en œuvre la solution proposée, mais ce n'est pas évident...

05/01/2012, 11h42
oodini

Par ailleurs, j'avais initialement mis mon opérateur à l'intérieur de l'espace de nommage concerné, et ça amrchait très bien.

Mais il m'a été dit qu"il fallait mettre les opérateurs binaires hors de tout espace de nommage, d'où mes actuels problèmes. Qu'en pensez-vous ?
05/01/2012, 12h24
Jean-Marc.Bourguet

Pour moi il faut mettre les operateurs libres dans le meme espace de nommage que les classes qu'ils manipulent. (Ce qu'il ne faut pas faire, c'est mettre des operateurs binaires comme membres de la classe, c'est peut-etre avec ca que tu confondais).

Citation:

Envoyé par oodini

en fait, mon problème ressemble assez à celui-ci. J'essaye de mettre en œuvre la solution proposée, mais ce n'est pas évident...

Bon, après avoir lutté pour faire la déclaration anticipée de mes templates compliqués, au final, il considère toujours qu'il y a un opérateur * défini dans l'espace de nommage à cause de la déclaration friend, malgré ce que j'ai ajouté (en rouge) :
Code:

1 2 3 4 5 template <class T1, template<class> class StorageT1, class T2, template<class> class StorageT2> friend Matrix<T1, StorageT1> (::operator*) (const Matrix<T1, StorageT1>& matrix1, const Matrix<T2, StorageT2>& matrix2);

05/01/2012, 12h48
screetch

ou bien une predeclaration de ton operateur * dans le namespace correct.
en effet, si lorsque tu mets ta declaration friend, le compilateur n'a pas encore vu ton operateur *, il va declarer l'operateur * dans le namespace courant.

si en revanche un operateur * a été declaré avant, et dans un namespace accessible, il va utiliser cette declaration.

le problème est donc que en ajoutant friend, tu as declaré un operator* au mauvais endroit.

remarque subsidiaire, ton operateur * dans le namespace global n'est pas friend de la classe puisque le compilo a compris ca différemment.

En l'occurrence, à présent, je déclare au début de mon code (mais après la déclaration anticipée de Matrix, rendue nécessaire...), en dehors de tout espace de nom :
Code:

1 2 3 4 5 template <class T1, template<class> class StorageT1, class T2, template<class> class StorageT2> monNamespace::Matrix<T1, StorageT1> operator * (const monNamespace::Matrix<T1, StorageT1>& matrix1, const monNamespace::Matrix<T2, StorageT2>& matrix2);
Ça devrait donc être bon.

05/01/2012, 14h03
Flob90

En général on met les opérateurs dans le même espace de nommage pour profiter de l'ADL.

Si tu les mets complétement au dehors j'ai peur que si un utilisateur définie le même opérateur que toi de manière générique (operator*(const T&, const T&)) dans son propre namespace et utilise ensuite dans son namespace tes matrices avec cet opérateur, l'appel ne soit pas celui attendu (alors qu'avec l'ADL ca serait bon).

Je t'invite au passage à lire les articles de Herb Sutter sur GotW à propos du concept de classe ("What is in a class ?" pour le titre de mémoire).

Pour illustrer mon propos précédent :

Code:

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
49
50
 
#include<iostream>
 
namespace N
{
	template<class T>
	struct A;
}
 
template<class T>
N::A<T> operator+(const N::A<T>&, const N::A<T>&);
 
namespace N
{
	template<class T>
	struct A
	{
		friend A (::operator+<>)(const A&, const A&);
	};
}
 
template<class T>
N::A<T> operator+(const N::A<T>&, const N::A<T>&)
{ 
	std::cout << 0;
	return N::A<T>();
}
 
namespace M
{
	template<class T>
	T operator+(const T&, const T&)
	{
		std::cout << 1;
		return T();
	}
 
	void foo()
	{
		N::A<int> a, b;
		a+b;
	}
}
 
int main()
{
	N::A<int> a, b;
	a+b;
	M::foo();
}

Ce code représente ce que tu fais actuellement avec un utilisateur qui rajoute le namespace M, l'opération a+b de foo affiche 1 : ce n'est pas le comportement que tu as prévu.

Code:

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>
 
namespace N
{
	template<class T>
	struct A;
 
	template<class T>
	A<T> operator+(const A<T>&, const A<T>&);
 
	template<class T>
	struct A
	{
		friend A operator+<>(const A&, const A&);
	};
 
	template<class T>
	A<T> operator+(const A<T>&, const A<T>&)
	{ 
		std::cout << 0;
		return A<T>();
	}
 
}
 
namespace M
{
	template<class T>
	T operator+(const T&, const T&)
	{
		std::cout << 1;
		return T();
	}
 
	void foo()
	{
		N::A<int> a, b;
		a+b;
	}
}
 
int main()
{
	N::A<int> a, b;
	a+b;
	M::foo();
}

La même chose en restant dans le namespace de la classe, cette fois l'opération a+b de foo a bien le comportement attendu : cela affiche 0.

En conclusion : les opérateurs doivent être dans le namespace des opérandes.

05/01/2012, 14h30
oodini

Citation:

Envoyé par Flob90

En général on met les opérateurs dans le même espace de nommage pour profiter de l'ADL.

Si tu les mets complétement au dehors j'ai peur que si un utilisateur définie le même opérateur que toi de manière générique (operator*(const T&, const T&)) dans son propre namespace et utilise ensuite dans son namespace tes matrices avec cet opérateur, l'appel ne soit pas celui attendu (alors qu'avec l'ADL ca serait bon).

Malheureusement, on m'impose de le définir en dehors de l'espace de nommage...

Citation:

Envoyé par Flob90

Je t'invite au passage à lire les articles de Herb Sutter sur GotW à propos du concept de classe ("What is in a class ?" pour le titre de mémoire).

Sur cette page, je n'ai rien trouvé qui s'en rapproche.
05/01/2012, 14h34
Flob90

C'est un projet scolaire ou un projet "réel" ? Dans le second cas tu pourrais essayer d'en discuter avec ton responsable.

http://www.gotw.ca/publications/mill02.htm

NB: J'ai posté un message supplémentaire pendant que tu écrivais le tien. Ca te montre que le défaut introduit est assez fort.
05/01/2012, 15h29
oodini

C'est un projet réél.

Je te remercie beaucoup pour le bout de code que tu as fait l'effort d'écrire.

Je suis en train de bosser dessus.

EDIT : c'est édifiant, effectivement :D
05/01/2012, 16h59
oodini

Bon, je suis allé voir mon responsable muni de ton code, avec al suggestion de jeter un œil sur Wikipedia (ADL).

Comme j'avais déjà essayé ce matin de le convaincre de rester dans le namespace, ça a été un peu tendu au début, mais finalement, j'ai remporté la victoire. :)

Merci beaucoup !