Discussion :

[Joel F]

Et bon, je trouve plus propre d'avoir un swap dans ton namespace et laissez l'ADL le trouver plutot que de hacker std. mais comme dis plus, préférences personelles.

[Goten]

On peut pas spécialiser partiellement une fonction template...

Sinon +1 pour l'ADL. J'aime pas ouvrir le namespace std dans mes fichiers... C'est psychologique sûrement.

[yan]

je trouve plus propre d'avoir un swap dans ton namespace et laissez l'ADL le trouver

c'est quoi l'ADL?
tu veut dire que si tu fait une fonction swap elle sera automatique utilisé??

[Goten]

argument dependent name lookup

C'est ce qui te permet d'écrire :

std::cout << "foo";

sans soucis. (ie t'éviter std::cout std::operator<<("foo"); )

[metagoto]

c'est quoi l'ADL?

da Argument Dependent name Lookup
aka Koenig lookup

edit: devancé par Goten (de peu)

[yan]

lol, on aprend des choses tous les jours
Par contre, comment tu définie le swap dans ton namespace pour que l'ADL trouve la bonne implémentation pour la STL?

J'ai beau essayer, j'y arrive pas (sous visual 2008)

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
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
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
namespace AA
{
    class A 
    {
    public :
	    A(int a) :nb(a)
        { 
        };
 
	    bool operator<(const A& a) 
        {
            return nb<a.nb;
        }
 
	    A&  operator=(const A& a) 
	    {
	        nb = a.nb;
	        return (*this);
	    }
 
	    void swap(A& a) 
	    {
		    std::swap(nb,a.nb);		
	    };
    private:
	    int nb;
 
    };
 
    template<typename T>
    void swap ( T& a, T& b )
    {
        std::cout<<"AA::std::swap"<<std::endl;
	    std::swap(a,b);
    };
    //specialisation de la fonction swap pour la class A
    template<>
    void swap<A> ( A& a, A& b )
    {
        std::cout<<"AA::swap"<<std::endl;
	    a.swap(b);
    };
}//fin namespace
 
 
 
template<>
 void std::swap<AA::A> ( AA::A& a, AA::A& b )
{
    std::cout<<"std::swap"<<std::endl;
	a.swap(b);
};
int main(int argc, char** argv)
{
 
 
	//mon vecteur a trier
    std::vector<AA::A> vect;
       //on remplie de n'importe quoi
    for(int i =0 ; i < 1000 ; ++i)
	    vect.push_back(AA::A(rand()));
 
 
     //on fait le trie
	std::sort(vect.begin(),vect.end());
 
AA::A a(10);
    AA::A b(20);
    swap(a,b);
return 0;
}

dans ce code, seule la spécialisation de la std est appelé lors du sort.

Seule swap(a,b) utilise le swap définie dans le namespace.

[metagoto]

lol, on aprend des choses tous les jours
Par contre, comment tu définie le swap dans ton namespace pour que l'ADL trouve la bonne implémentation pour la STL?

Dans le lien que tu as posté de Sutter:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Example 4(c): Overloading swap().
//
class MyClass
{
public:
  void Swap( MyClass& ) throw();
  // ...
};
 
// NOTE: Not in namespace std.
swap( MyClass& a, MyClass& b ) // throw()
{
  a.Swap( b );
}

[yan]

si je fait (dans le code précédent et un S majuscule dans la fonction de la classe)

Code :

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

1
2
3
4
5
swap ( A& a, A& b )
    {
       // std::cout<<"AA::swap"<<std::endl;
	    a.Swap(b);
    };

visual me fait

spécificateur de type manquant - int est pris en compte par défaut.

et si je fait

Code :

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

1
2
3
4
5
void swap ( A& a, A& b )
    {
       // std::cout<<"AA::swap"<<std::endl;
	    a.Swap(b);
    };

la fonction n'est appelé que par swap(a,b) et jamais par le sort.

Je doit bien m'être planté quelque part mais je ne voie pas ou...

[metagoto]

Et si tu mets ceci dans AA::A:

Code :

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

1
2
private:
    friend bool operator<(A const& a, A const& b);

Puis dans AA:

Code :

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

1
2
3
4
bool operator<(A const& a, A const& b)
{
    return a.nb<b.nb;
}

Edit: finalement, j'ai testé (avec gcc). Ca fonctionne:

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
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
 
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
#include <iterator>
 
namespace AA
{
  class A 
  {
    public:
      A(int a) :nb(a)
      { 
      };
 
      bool operator<(const A& a) 
      {
        return nb<a.nb;
      }
 
      A& operator=(const A& a) 
      {
        nb = a.nb;
        return (*this);
      }
 
      void swap(A& a) 
      {
        std::swap(nb,a.nb);   
      };
 
    private:
      int nb;
      friend bool operator<(const A& a, const A& b);
      friend std::ostream& operator<<(std::ostream& o, A const& a);
  };
 
  void swap ( A& a, A& b )
  {
    std::cout<<"AA::swap"<<std::endl;
    a.swap(b);
  };
 
  bool operator<(const A& a, const A& b)
  {
    return a.nb<b.nb;
  }
 
  std::ostream& operator<<(std::ostream& o, AA::A const& a) {
    return o << a.nb;
  }
 
}//fin namespace
 
 
int main(int argc, char** argv)
{
 
  //mon vecteur a trier
  std::vector<AA::A> vect;
  //on remplie de n'importe quoi
  for(int i =0 ; i < 1000 ; ++i)
    vect.push_back(AA::A(rand()));
 
  //on fait le trie
  std::sort(vect.begin(),vect.end());
 
  std::copy(vect.begin(), vect.end(), std::ostream_iterator<AA::A>(std::cout, ","));
 
  AA::A a(10);
  AA::A b(20);
  swap(a,b);
  return 0;
}

(désolé, l'indentation doit être merdique)

[yan]

Et si tu mets ceci dans AA::A:

Code :

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

1
2
private:
    friend bool operator<(A const& a, A const& b);

Puis dans AA:

Code :

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

1
2
3
4
bool operator<(A const& a, A const& b)
{
    return a.nb<b.nb;
}

je voie pas trop ce que cela changerai... mais ça na rien changé.


Par contre sous gcc ça marche.

Si je regarde le code de sort, visual utilise std::swap alors que gcc utilse swap. C'est dans la définition de iter_swap

Donc ca expliquerai mon problème.
[edit]
Si je remplace std::swap par swap dans le fichier algorithm de visual, ça marche... Mais bon, je suis pas sur que c'est une solution...

[koala01]

[edit]
Si je remplace std::swap par swap dans le fichier algorithm de visual, ça marche... Mais bon, je suis pas sur que c'est une solution...

Par défaut, c'est une très très très mauvaise idée que de vouloir aller modifier un fichier d'en-tête standard (ou de toute bibliothèque dont tu ne dispose pas explicitement le code source d'ailleurs )

Il ne faut pas oublier que, malgré que la bibliothèque standard soit en grande partie basée sur des template, il est possible d'avoir des dlls ou des en-têtes pré compilées de celle-ci (quand on compile gcc avec l'option --enable-shared, on obtient une dll stdc++ et une autre supc++), même si on se doute parfaitement que les parties implémentées par celles-ci ne peuvent forcément pas être prévues pour fonctionner avec n'importe quel type (sans doutes les types primitifs, les std::string et les différent I/Ostream ?)

Si tu modifie le fichier d'en-tête standard sans faire attention, va savoir quelles régressions tu risques d'occasionner en espérant résoudre un problème pouvant être considéré comme marginal

[yan]

Si tu modifie le fichier d'en-tête standard sans faire attention, va savoir quelles régressions tu risques d'occasionner en espérant résoudre un problème pouvant être considéré comme marginal

t'inquiète c'était juste pour tester
c'est bien pour cela que 'ai dit que c'était pas une solution.

Je suis étonné que visual et gcc ont un comportement différent sur ce point...

[koala01]

t'inquiète c'était juste pour tester
c'est bien pour cela que 'ai dit que c'était pas une solution.

Je me doutais que, venant de toi, il n'y avait pas énormément de risques que tu laisse le fichier d'en-tête ainsi modifié, mais je voulais surtout attirer l'attention de toute personne lisant cette discussion sur le fait que c'était une très mauvaise idée (des fois qu'il y ait un quidam quelconque qui puisse croire que c'était la solution à son problème )

Je suis étonné que visual et gcc ont un comportement différent sur ce point...

Pour peu (je n'ai pas été vérifier) que la norme n'ait pas été très précise sur la manière de s'y prendre, ou qu'elle ait précisé que c'était défini par l'implémentation, ce n'est pas *forcément* surprenant...

Il faut aussi voir les "casseroles" tirées par l'historique des différents compilateurs sur le sujet...

Je rappelle quand même que, jusqu'à il n'y a que quelques années, microsoft était connu pour ne respecter les normes que de la manière qu'il voulait bien (non, je n'essaye pas de relancer un troll... toute allusion à cette dernière phrase sera supprimée "a vue" )

[yan]

Je viens de tester au travaille. Sous visual 2008 sp1 ça marche en faite.
La fonction iter_swap utilise bien swap.

Chez moi j'utilise visual 2008 express et c'est avec lui que ça ne marche pas
Il me semblais que la version express correspondait à visual 2008 sp1 pour la compilation.

[Jean-Marc.Bourguet]

J'ai pas le temps de chercher quel est l'etat actuel, d'autant plus que l'abandon des concepts a du avoir un effet important. Voir http://www.open-std.org/jtc1/sc22/wg...2001/n1296.asc pour C++98