impossible d'utiliser une clé de type complex dans un map !

Boujours,

Après avoir passé beaucoup de temps à chercher la solution, j'en appel à vôtre aide :

Je ne comprend pas pourquoi la compilation plante lorsque je veux utiliser une clé de type complex dans un map!

Voici un bout de code reproduisant le problème :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <string>
#include <map>
#include <list>
#include <complex>
#include <iostream>
 
using namespace std;
 
int main ( int argc, char *argv[] ) {
 
	typedef string		 action;
	typedef complex<int> state;	//PROBLEME avec le type complex !!!!
	//typedef string state;	//Compilation OK en remplaçant complex<int> par string
	//typedef int state;	//Compilation OK en remplaçant complex<int> par int
 
	map< state, action > monMap;
	action mouvement = "azerty";
	state etat = complex<int>(-1,-1);	//PROBLEME avec le type complex !!!!
	//state etat = "coucou";//Compilation OK en remplaçant complex<int> par string
	//state etat = 2;	//Compilation OK en remplaçant complex<int> par int
 
	monMap[etat] = mouvement;
}

Ce code ne compile pas si le typedef state est du type complex alors qu'il compile sans problèmes avec d'autre types ( j'ai essayé en mettant string ou int ) ( Le compilateur utilisé est VS2008 )

Voici ce que me raconte le compilateur :

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
------ Build started: Project: Fourre_Tout_Console, Configuration: Debug Win32 ------
Compiling...
Fourre_Tout_Console.cpp
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::list<_Ty,_Ax> &,const std::list<_Ty,_Ax> &)' : could not deduce template argument for 'const std::list<_Ty,_Ax> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\list(1310) : see declaration of 'std::operator <'
        d:\program files\microsoft visual studio 9.0\vc\include\functional(142) : while compiling class template member function 'bool std::less<_Ty>::operator ()(const _Ty &,const _Ty &) const'
        with
        [
            _Ty=state
        ]
        d:\program files\microsoft visual studio 9.0\vc\include\map(68) : see reference to class template instantiation 'std::less<_Ty>' being compiled
        with
        [
            _Ty=state
        ]
        d:\program files\microsoft visual studio 9.0\vc\include\xtree(22) : see reference to class template instantiation 'std::_Tmap_traits<_Kty,_Ty,_Pr,_Alloc,_Mfl>' being compiled
        with
        [
            _Kty=state,
            _Ty=action,
            _Pr=std::less<state>,
            _Alloc=std::allocator<std::pair<const state,action>>,
            _Mfl=false
        ]
        d:\program files\microsoft visual studio 9.0\vc\include\xtree(63) : see reference to class template instantiation 'std::_Tree_nod<_Traits>' being compiled
        with
        [
            _Traits=std::_Tmap_traits<state,action,std::less<state>,std::allocator<std::pair<const state,action>>,false>
        ]
        d:\program files\microsoft visual studio 9.0\vc\include\xtree(89) : see reference to class template instantiation 'std::_Tree_ptr<_Traits>' being compiled
        with
        [
            _Traits=std::_Tmap_traits<state,action,std::less<state>,std::allocator<std::pair<const state,action>>,false>
        ]
        d:\program files\microsoft visual studio 9.0\vc\include\xtree(107) : see reference to class template instantiation 'std::_Tree_val<_Traits>' being compiled
        with
        [
            _Traits=std::_Tmap_traits<state,action,std::less<state>,std::allocator<std::pair<const state,action>>,false>
        ]
        d:\program files\microsoft visual studio 9.0\vc\include\map(78) : see reference to class template instantiation 'std::_Tree<_Traits>' being compiled
        with
        [
            _Traits=std::_Tmap_traits<state,action,std::less<state>,std::allocator<std::pair<const state,action>>,false>
        ]
        d:\visual studio 2010\projects\fourre_tout_console\fourre_tout_console\fourre_tout_console.cpp(16) : see reference to class template instantiation 'std::map<_Kty,_Ty>' being compiled
        with
        [
            _Kty=state,
            _Ty=action
        ]
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::list<_Ty,_Ax> &,const std::list<_Ty,_Ax> &)' : could not deduce template argument for 'const std::list<_Ty,_Ax> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\list(1310) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::list<_Ty,_Ax> &,const std::list<_Ty,_Ax> &)' : could not deduce template argument for 'const std::list<_Ty,_Ax> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\list(1310) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::_Tree<_Traits> &,const std::_Tree<_Traits> &)' : could not deduce template argument for 'const std::_Tree<_Traits> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xtree(1466) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::_Tree<_Traits> &,const std::_Tree<_Traits> &)' : could not deduce template argument for 'const std::_Tree<_Traits> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xtree(1466) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::_Tree<_Traits> &,const std::_Tree<_Traits> &)' : could not deduce template argument for 'const std::_Tree<_Traits> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xtree(1466) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::basic_string<_Elem,_Traits,_Alloc> &,const _Elem *)' : could not deduce template argument for 'const std::basic_string<_Elem,_Traits,_Alloc> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\string(150) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::basic_string<_Elem,_Traits,_Alloc> &,const _Elem *)' : could not deduce template argument for 'const std::basic_string<_Elem,_Traits,_Alloc> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\string(150) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::basic_string<_Elem,_Traits,_Alloc> &,const _Elem *)' : could not deduce template argument for 'const std::basic_string<_Elem,_Traits,_Alloc> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\string(150) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const _Elem *,const std::basic_string<_Elem,_Traits,_Alloc> &)' : could not deduce template argument for 'const _Elem *' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\string(140) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::basic_string<_Elem,_Traits,_Alloc> &,const std::basic_string<_Elem,_Traits,_Alloc> &)' : could not deduce template argument for 'const std::basic_string<_Elem,_Traits,_Alloc> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\string(130) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::basic_string<_Elem,_Traits,_Alloc> &,const std::basic_string<_Elem,_Traits,_Alloc> &)' : could not deduce template argument for 'const std::basic_string<_Elem,_Traits,_Alloc> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\string(130) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::basic_string<_Elem,_Traits,_Alloc> &,const std::basic_string<_Elem,_Traits,_Alloc> &)' : could not deduce template argument for 'const std::basic_string<_Elem,_Traits,_Alloc> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\string(130) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)' : could not deduce template argument for 'const std::reverse_iterator<_RanIt> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xutility(2236) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)' : could not deduce template argument for 'const std::reverse_iterator<_RanIt> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xutility(2236) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::reverse_iterator<_RanIt> &,const std::reverse_iterator<_RanIt2> &)' : could not deduce template argument for 'const std::reverse_iterator<_RanIt> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xutility(2236) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::_Revranit<_RanIt,_Base> &,const std::_Revranit<_RanIt2,_Base2> &)' : could not deduce template argument for 'const std::_Revranit<_RanIt,_Base> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xutility(2046) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::_Revranit<_RanIt,_Base> &,const std::_Revranit<_RanIt2,_Base2> &)' : could not deduce template argument for 'const std::_Revranit<_RanIt,_Base> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xutility(2046) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::_Revranit<_RanIt,_Base> &,const std::_Revranit<_RanIt2,_Base2> &)' : could not deduce template argument for 'const std::_Revranit<_RanIt,_Base> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\xutility(2046) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::pair<_Ty1,_Ty2> &,const std::pair<_Ty1,_Ty2> &)' : could not deduce template argument for 'const std::pair<_Ty1,_Ty2> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\utility(84) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::pair<_Ty1,_Ty2> &,const std::pair<_Ty1,_Ty2> &)' : could not deduce template argument for 'const std::pair<_Ty1,_Ty2> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\utility(84) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2784: 'bool std::operator <(const std::pair<_Ty1,_Ty2> &,const std::pair<_Ty1,_Ty2> &)' : could not deduce template argument for 'const std::pair<_Ty1,_Ty2> &' from 'const state'
        d:\program files\microsoft visual studio 9.0\vc\include\utility(84) : see declaration of 'std::operator <'
d:\program files\microsoft visual studio 9.0\vc\include\functional(143) : error C2676: binary '<' : 'const state' does not define this operator or a conversion to a type acceptable to the predefined operator
Build log was saved at "file://d:\visual studio 2010\Projects\Fourre_Tout_Console\Fourre_Tout_Console\Debug\BuildLog.htm"
Fourre_Tout_Console - 23 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Une map maintient un ordre, et pour cela utilise l'opérateur < pour comparer les clés.
Pour des clés de type int, string, il n'y a pas de problèmes.
Mais comparer 2 complexes, ...

Ca a l'air pas bête ce que tu dis ;) , je vais chercher comment changer la relation d'ordre de mon map pour en imposer une "faite maison"... Il me semble que c'est possible, je crois l'avoir déjà fait une fois... ( si quelqu'un à une piste, je n'arrive pas à retrouver la procédure pour faire ça : je vais fouiller dans la doc de référence... )

Merci.

tu peux toujours ajouter un opérateur de comparaison fonctionnant sur les complexes :
Code:

1 2 3 bool operator < (std::complex const& c1, std::complexconst& c2) { return (c1.real() < c2.real()) || ((c1.real() == c2.real()) && (c1.imag() < c2;imag())); }
Mais ça n'a pas de sens au niveau mathématique !

Aucun souci si ça n'as pas de sens au niveau mathématique Guillaume, je veux seulement pouvoir créer un map avec un complex comme clé... C'est parfait:ccool:.

Je me suis inspiré de ce qu' proposé Guillaume dans le post ci-dessus et de ce que j'ai trouvé dans la doc de référence ( constructeur de map sur cplusplus.com )...

Ca donne ça et ça compile pile poil ;) !!!
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 #include <string> #include <map> #include <list> #include <complex> #include <iostream> using namespace std; bool fncomp (complex<int> c1, complex<int> c2) { return (c1.real()<c2.real()) || ( (c1.real()==c2.real()) && (c1.imag()<c2.imag())); } bool(*fn_pt)(complex<int>,complex<int>) = fncomp; int main ( int argc, char *argv[] ) { typedef string action; typedef complex<int> state; map< state, action, bool(*)(complex<int>,complex<int>) > monMap (fn_pt); action mouvement = "azerty"; state etat = complex<int>(-1,-1); monMap[etat] = mouvement; }
Merci à Xtrem_Voyageur :ccool: et à Guillaume :ccool:

Ca marche, mais ce n'est assurément pas optimal. En effet, tu utilises un pointeur de fonction là où un foncteur te permettrait de bénéficier de l'inlining...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class ComplexComparer { bool operator()(complex<int> c1, complex<int> c2) { return (c1.real()<c2.real()) || ( (c1.real()==c2.real()) && (c1.imag()<c2.imag())); } }; int main() { map< state, action, ComplexComparer> monMap; }

peut être qu'une unordered_map serait ici plus adaptée?

Merci pour ton message Loïc, la solution avec le foncteur est également plus lisible que celle avec le pointeur de fonction. Je vais l'utiliser.

Merci Cédric, l'utilisation de unordered_map semble également être une solution correcte ( j'ai survolé la doc de unordered_map rapidement sans rentrer dans le détail )

Citation:

Envoyé par CedricMocquillon

peut être qu'une unordered_map serait ici plus adaptée?

Ne ne suis pas convaincu a priori. Au lieu de définir une relation d'ordre, on va devoir définir une fonction de hash. Ce qui me semble bien plus complexe. Donc à moins d'avoir des millions d'éléments...

Ce que je me demande surtout c'es quel est ce rôle de complexe<int>. Va-t-on faire des opérations mathématiques avec ? Une pair<int, int> ne serait-elle pas plus adaptée ? A noter :

Citation:

The effect of instantiating the template complex for any type other than float, double or long double is unspecified.

Citation:

Envoyé par JolyLoic

Ce que je me demande surtout c'es quel est ce rôle de complexe<int>. Va-t-on faire des opérations mathématiques avec ? Une pair<int, int> ne serait-elle pas plus adaptée ?

J'utilise le type complex<int> pour stocker des coordonnées sur une grille et des déplacements relatifs sur cette même grille.

J'avais donc besoins d'un type que stockait 2 entiers et qui avait définit l'operator + tel qu'il est définit pour les complexes ou les vecteurs 2d des mathématiques . J'imagine que des problèmes peuvent apparaitre si je veux calculer un module ou un argument sur ces complex<int>... mais ici je n'utiliserai en aucun cas ces fonctions! ( Je n'utilise ici que le constructeur, l'affectation et operator+ )

J'ai trouvé que le type complex<int> était adapté à mes besoins... La simple pair<int,int> n'était pas, à mon avis, adaptée à cette utilisation ( pas d'operator+ je crois ).

C'est vrai que pour les unordered_map, j'utilise celles de boost qui fourni une fonction de hash pour les principaux types. Je ne sais pas ce que dit la norme là dessus mais boost fourni une spécialisation pour les complexes:

Citation:

std::complex<T> When T is a built in type and val.imag() == 0, the result is equal to hash_value(val.real()). Otherwise an unspecified value, except that equal arguments shall yield the same result.

J'avoue également ne jamais avoir manipulé les complexes du standards et encore moins dans une map ou une unordered donc je ne me rend pas du tout compte du bien fondé de ma proposition.
C'est juste peut être une piste de plus à explorer qui peut éventuellement résoudre le problème de sémantique à définir un opérator < puisque dans les cas des boost::unordered_map, on peut se limiter à l'opérateur !=.

bertry, d'après ta réponse, j'en déduis que ce n'est pas forcément un bon choix d'utiliser les complexes (la sémantique est différente, c'est un bon indice d'un problème), tu aurais pu par exemple définir ta propre classe Point2D. Je crois que Boost géometry propose une classe dans ce goût là (je ne m'en suis personnellement pas servis), sinon Koala avait tenté une lib d'IHM (elle s'appelait farfelue si je me souvient bien) il avait pas mal réfléchi dessus...

Il y a aussi les valarray, non ?

Citation:

Envoyé par Ekleog

Il y a aussi les valarray, non ?

Non, pas dans ce cas!

Citation:

Envoyé par bertry

Non, pas dans ce cas!

Je me suis trompé, valarray peut tout à fait remplacer complex dans ce cas, il permet en plus de ne pas être limité à un environnement 2d comme avec les complexs.
Toutes mes excuses Ekleog :ccool: