C++

swap idiom

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : swap idiom

Glock 17Pro

Quel est l'intérêt de cet idiom, j'ai jamais eu à faire du swap dans mes applis finalement, pourquoi est ce qu'on retrouve ça ici et là ?
pourquoi dans l'operateur dassignement ?
dans l'operateur = on veut pas swaper, on veut affecter....

---------------
.

Publicité

Joel F

Real men use shared_ptr

quand tu swap pour affecter, tu laisse au systeme la charge de creer la nouvelle mémoire, copier et liberer l'ancienne. C'ets beaucoup plus simple à ecrire, ca evite l'horrible if(this !=asource) et ca a une strong guarantee sur les exceptions.

Code :

A& operator=( A source )
{
swap(source);
return *this;
}

ca a l'air mieux que la vielle forme et ca evite la duplication de code du copy-ctor

Message édité par Joel F le 07-11-2009 à 16:58:07

---------------
MetaScale | Mes cartes Magic

Glock 17Pro

pourtant ici on se retrouve bien à faire de l'auto affectation si ça se produit :

template<class T>
void swap (T &a, T &b)
{
T temp (a);
a = b;
b = temp;
}

Message cité 1 fois

---------------
.

Glock 17Pro

et d'ailleurs quel est le pbm posé par l'auto-affect ?

(2 questions donc au final)

---------------
.

Un Programmeur

C'est bien sûr à ne pas faire si on n'a pas un swap spécialisé pour la classe (soit une spécialisation de std::swap, soit une version dans le namespace de la classe).

L'idée derrière le passage par valeur de A -- idiome qu'on ne voit que depuis relativement peu de temps -- est de profiter de la possibilité d'élision du constructeur de copie quand on passe un temporaire.

---------------
The truth is rarely pure and never simple (Oscar Wilde)

Joel F

Real men use shared_ptr

Glock 17Pro a écrit :

pourtant ici on se retrouve bien à faire de l'auto affectation si ça se produit :

template<class T>
void swap (T &a, T &b)
{
T temp (a);
a = b;
b = temp;
}

Non ton swap il ets spécialisé pour ta classe et va swapper ses membre :E
l'auto affect c'ets la crap quand tu detruit l'ancien avant d'y copier le nouveau

---------------
MetaScale | Mes cartes Magic

Glock 17Pro

tout à fait. Rien à rajouter à ça.

l'auto affect c'ets la crap quand tu detruit l'ancien avant d'y copier le nouveau :o

idem

Non ton swap il ets spécialisé pour ta classe et va swapper ses membre :E

Pourquoi swapper et ne pas se contenter de faire this->membre1 = obj.membre1;

Code :

namespace std{
template<>
void swap<MaClasse>(Maclasse& obj)
{
this->IntMembre1 = obj.IntMembre1
// versus
swap(this->IntMembre1,obj.IntMembre1)
}
}

Message édité par Glock 17Pro le 07-11-2009 à 18:45:33

---------------
.

Joel F

Real men use shared_ptr

il faut swapper pour que le veil objet soit detruit automagiquement quand la copie sort de scope.

---------------
MetaScale | Mes cartes Magic

Glock 17Pro

merde je vois pas ce que tu veux dire là on a donc

Code :

A& operator=( A source )
{
swap(source);
return *this;
}

Code :

namespace std{
template<>
void swap<MaClasse>(Maclasse& obj)
{
swap(this->IntMembre1,obj.IntMembre1)
}
}

à quel endroit ça ne serait pas auto destruct si pas de swap ?

---------------
.

Joel F

Real men use shared_ptr

Bon, je vais te sortir l'exempel que je file à mes étudiants de première année ...

la bonne vieille classe array<T>

Code :

template<class T> struct array
{
public:
array() : data(0), size(0) {}
~array() { if(data) delete[] data; size = 0; }
array( array<T> const& source )
{
data = new T[source.size()];
size = source.size();
std::copy(source.begin(),source.end(),this->begin());
}
array& operator( array source )
{
swap(source);
return *this;
}
// autre methodes trivialles
protected:
void swap(array& source)
{
std::swap(data,source.data);
std::swap(size,source.size);
}
private:
T* data;
std::size_t size;
};
template<class T> inline
void swap( array<T>& a, array<T>& b )
{
a.swap(b);
}

L'idée est de swap le contenu du lhs de op= avec le rhs temporaire.
Comme ça, à la sortie de )=, le lhs contient le rhs (affectation) et le rhs contient le lhs. Comme le rhs sort de scope, il est détruit, libérant les ressources de l'ancienne instance

---------------
MetaScale | Mes cartes Magic

Glock 17Pro

ah yes j'ai enfin capté, ty.
tu le mets pas dans le std, le swap spécialisé ? c'est inutile ?

Message édité par Glock 17Pro le 08-11-2009 à 17:12:46

---------------
.

Joel F

Real men use shared_ptr

normalement, t'as pas le droit d'ouvrir std pour y foutre des specialisations.

Si tu le mets dans le namespace de ta classe, le Koenig's Lookup va le trouver tout seul.

---------------
MetaScale | Mes cartes Magic

Un Programmeur

D'après la norme (le dernier draft a une formulation très légèrement différente):

Citation :

It is undefined for a C++ program to add declarations or definitions to namespace std unless otherwise specified. A program may add template specializations for any standard library template to namespace std. Such specilization (complete or partial) of a standard library template results in undefined behavior unless the declaration depends on a user-defined name of external linkage and unless the specialization meets the standard library requirements for the original template.

Mais attention le swap de Joel n'est pas une specialisation mais une surcharge.

Voir http://www.open-std.org/jtc1/sc22/ [...] /n1296.asc

---------------
The truth is rarely pure and never simple (Oscar Wilde)

Glock 17Pro

ok , donc un code commme :

Code :

namespace std{
template<>
void swap<MaClasse>(Maclasse& obj, Maclasse& obj2)
{
swap(obj.IntMembre1,obj2.IntMembre1)
}
}

et tout à fait valide , so

Message édité par Glock 17Pro le 09-11-2009 à 13:02:26

---------------
.

Publicité

FORUM HardWare.fr

Programmation

C++

swap idiom

Sujets relatifs
Système...	swap image avec OnMouseOver sur un select
swap d'images [résolu]	Qu'est ce que sait que le swap?
[STL] surcharge ? spécialisation ? de swap()	fonction swap en delphi
Plus de sujets relatifs à : swap idiom

Page générée en 0.297 secondes