LE SWAP LE PLUS CRADE DE L'HISTOIRE DU C++
trinitacs
Messages postés
249
Date d'inscription
mardi 16 juillet 2002
Statut
Membre
Dernière intervention
7 août 2003
-
31 janv. 2003 à 19:26
hsaturn Messages postés 14 Date d'inscription jeudi 6 octobre 2005 Statut Membre Dernière intervention 3 juin 2007 - 22 mars 2010 à 09:46
hsaturn Messages postés 14 Date d'inscription jeudi 6 octobre 2005 Statut Membre Dernière intervention 3 juin 2007 - 22 mars 2010 à 09:46
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/10352-le-swap-le-plus-crade-de-l-histoire-du-c
https://codes-sources.commentcamarche.net/source/10352-le-swap-le-plus-crade-de-l-histoire-du-c
22 mars 2010 à 09:46
5 ans de retard désormais !!!! :-P
Je vais me mettre au Cobol et poster une réponse dans 12 ans. Puis au fortran et poster dans 20 ans ?
Tu seras toujours la ? :-D
Sinon, j'ai eu un cas récent d'utilisation de la méthode XOR sur un PIC ou la mémoire ET les registres sont comptés sur LE doigt de la main.
Economiser un octet ou un registre peu parfois être très confortable. Sur un RISC, c'est aussi rapide qui plus est.
Lol, qui relèvera le défit de répondre once again :-) ?
9 oct. 2005 à 22:41
(t'as 2 ans et 3 mois de retard :P)
7 oct. 2005 à 14:54
// ca donne ça et ça marche pour tout !
// J'aime po les macros.
#include <string>
#include
using namespace std;
template <class T>
void SWAP(T &t1,T &t2)
{
T t=t1;
t1=t2;
t2=t;
}
void main()
{
int i=2,j=1;
SWAP(i,j);
cout << i << j << endl;
string s1(" après");
string s2("avant");
SWAP(s1,s2);
cout << s1 << s2 << endl;
}
8 juil. 2003 à 19:23
8 juil. 2003 à 12:40
Pour le bug avec 0, je ne sais plus trop où il était.
8 juil. 2003 à 04:06
http://graphics.stanford.edu/~seander/bithacks.html
soit ton site :) aller, sans rencune ;)
sinon je n'aime pas trop les gents qui ecrivent un algo comme des porc et qui ensuite disent : "ahh, regarder comme c'est degueulasse, c'est cool non ?"
#define SWAP(a, b) ((a) ^= (b), (b) ^= (a), (a) ^= (b))
ceci est tres propre, et tres fonctionnel, de plus, je ne sais pas comment tu t'y es pris mais je n'ai pas le bug avec le zero dans une variable
trintacts, je pense quil est fort bien quil y ai peut de commentaire dans un code, justement, du commentaire dans un code ne contribue qu'a le salir d'avantage, un code bien ecrit ne necessite pas de commentaire, il parle de lui meme
de plus niff, ce contenter de ne pas gagner qqes microseconde est une bien grosse erreur car lorsque que tu fera ce genre d'operation des millions de fois par secondes, comptes le nombre de temps que tu pourrais gagner, meme un cycle d'horloge est toujours bon a gratter :)
golden-eye, te referer aux doc d'intel est vain, ce n'est pas en cherchant les cycle d'horloge des instructions asm que tu trouvera des reponses, il faut faire des tests sur le terrain
il a ete demontrer a maintes reprises que des instructions plus courtes que d'autre en temps cpu s'avairais plus longues car elle faisais appel a des fonctionnaliters plus lentes du sytemes, mais ca, je te laisse en discuter avec tes amis de ASM-France, ce genre de conversation n'as pas ca place ici, et je suis desoler d'en avoir mis
17 avril 2003 à 12:18
Si une des deux varaibles est à zéro, lorsque l'on fait a^=0 cela met les deux variables à zéro.
Sinon GoldenEye toi qui ramène ton code asm tu connais pas XCHG eax, ebx ?
4 févr. 2003 à 20:22
4 févr. 2003 à 17:01
exg %d0,%d1 en gnu asm m68k
2 févr. 2003 à 15:16
en asm "
J'irai voir chez intel car cela dépend de beaucoup de choses donc ne dit pas des trucs sans preuves.
"xor eax,eax "
Forcément on ne pas faire plus près que d'un registre au même registre. Mais ton code source C traduit en asm ne peut pas avoir ça. Alors ne dit pas des choses non fondées.
NiFF << "mais plutot de proposer une alternative interressante au niveau de la technique"
Je ne suis pas d'accord car c'est le genre de code compliqué peu abordable et qui nécessite obligatoirement un commentaire (chose rare chez beaucoup de programmeurs). C'est plutôt le genre de code a utilisé pour les concours du code source les plus illisible mais qui fonctionne (si si ça existe).
1 févr. 2003 à 14:58
1 févr. 2003 à 13:24
Le code assembleur généré est le suivant
Méthode XOR:
mov edx, DWORD PTR [ecx]
mov esi, DWORD PTR [eax]
xor esi, edx
mov DWORD PTR [eax], esi
mov edx, esi
mov esi, DWORD PTR [ecx]
xor esi, edx
mov DWORD PTR [ecx], esi
mov edx, esi
mov esi, DWORD PTR [eax]
xor esi, edx
mov DWORD PTR [eax], esi
Méthode classique :
mov esi, DWORD PTR [ecx]
mov eax, DWORD PTR [edx]
mov DWORD PTR [edx], esi
mov DWORD PTR [ecx], eax
ça se passe de commentaires.
1 févr. 2003 à 00:05
Je connaissais aussi, ça qui évite une déclaration
a+=b;//les deux (a+b) dans a
b=a-b;//retire b de (a+b) reste a
a=a-b;//retire a de (a+b) reste b
31 janv. 2003 à 22:45
31 janv. 2003 à 22:35
en asm : xor eax,eax est plus rapide que move eax,ebx
il faut voir ce que le compilateur génère en fait...
31 janv. 2003 à 22:32
31 janv. 2003 à 22:13
31 janv. 2003 à 19:26