bah c'est facile ...
c = a;
a = b;
b = c;
 
oui, mais savez vous que c'est possible sans troisieme varible !
Sans aucune variable intermediaire (et sans bidouille du genre l'instruction XCHG du processeur)
 
Alors, qui a une idee ?

tu me dis si je me trompe, mais la bidouille sans 3ième variable ne marche que sur des nombres, non?

dropsy: non, pkoi que avec des nombres?
 
je crois pas que ca existe pas sans troisieme var...

[edtdd]--Message édité par TheJackal--[/edtdd]

push a
push b
pop a  
pop b
 
autre chose ? sinon y'a un bidouille à coups de xor je crois ...

 
bon, alors g pas la bonne méthode
 
moi je fais:
a=a+b;
b=a-b;
a=a-b;
 
mais c pas jolie pr une string

pour un char* non pas du tout

[edtdd]--Message édité par TheJackal--[/edtdd]

TheJackal a écrit a écrit : pour un char* non pas du tout

caste le en long pour faire l'operation

moi je dit avec ce coup la HelloWorld a droit a une promotion    
 
ct quoi le deuxieme mot qu'ils ont dit      
 
sinon dropsy il etait pas loin

Bien joue dropsy !
Donc je confirme :
 
a = a+b;  
b = a-b;  
a = a-b;
 
youdontcare>
push a  
push b  
pop a  
pop b  
 
t'utilises non pas une variable intermediaire mais carement deux ...
he! la pile, ca prend de la place !

   
bon, ben g bon     ms se pose toujours le pbm des strings, non??    

hum, c'est pas faux.
j'y avais pas pense a ca.
mais, attend voire ...

 
sattisfait ?

ouaips ca a une tete sympa

échange moi les valeurs,
 
a = (2^32)-1;
b = (2^32)-2;
 
avec a et b en unsigned long.

Problème connu en ASM pour échanger 2 valeurs quelconques :
 
a = a xor b
b = a xor b
a = a xor b
 
difficile de faire plus rapide en terme de cycle : 3 XOR au lieu de 3 MOV et une variable supplémentaire.

[edtdd]--Message édité par n0mad--[/edtdd]

BENB a écrit a écrit :   caste le en long pour faire l'operation

 
note que ça doit marcher, on ne fait qu'échanger des pointeurs, c'est des entiers
d'ailleurs char* est un entier, puisque pointeur vers une chaîne de caractère... (non ? je sais plus )

antp a écrit a écrit :     note que ça doit marcher, on ne fait qu'échanger des pointeurs, c'est des entiers d'ailleurs char* est un entier, puisque pointeur vers une chaîne de caractère... (non ? je sais plus )

 
Oui ca marche.... mais c'est pas beau

 
oui mais ................. i c bien une variable, non    
alors ca compte qd même ou pas  

BENB a écrit a écrit :     Oui ca marche.... mais c'est pas beau

 
pas beau ? on ne fait qu'échanger des pointeurs !!
c'est nettement plus beau que la solution de recopier caractère par caractère (quel est l'intérêt de bouger toute la mémoire quand il suffit de bouger les références)

tu prends, tu vires,
 
ca marche que sous certaines conditions. Puis alors, le coup des additions et soustractions de pointeur, faut pas déconner.
 
A = adresse X
B = X+1
 
A = A + B donne adresse de A = indéterminé = peut correspondre a une adresse d'un autre process ou thread. Il va apprécier le SE, s'il te jette pas avec un truc du genre ' A effectuer une opératon non conforme' de temps en temps je mange un balai
 
Vous vous entrainez pour postuler a un post chez Microsoft ou quoi ?

[edtdd]--Message édité par Barbarella--[/edtdd]

a=2
b=5
 
b=a+b  // a=2, b=7
a=b-a  // a=5, b=7
b=a-b  // a=5, b=2
 
voila je crois que ca marche bien !!!

c plus lent que le premier ex, et puis essaye avec des pointeurs comme dropsy voulait faire

ah bon? je voulais faire ca avec des pointeurs?
non, ce que je dis, c que la solution que je donne marche pour ce qui est des nombres (et encore, à condition de pas dépasser les limites de ces nombres)
après, pour des pointeurs... c un autre pbm

je ne vois pas pourquoi la solution xor ne marcherait pas tout le temps et sur tous types de variables (flottants, entiers, pointeurs ...)  

c'est le cast qui n'est pas beau... et comme le dis Barbarella
le ponteur qui a recu a+b il pointe n'importe ou...
et il y a le Pb des limites sur les station HP sur lequelles je travaillais il n'y a pas si longtemps les adresse memoire commecaient toutes par 0x8.....

 
C'est pour ça que ma méthode avec XOR (un peu plus haut dans le thread) est bien plus soft car il n'y a pas de risque de dépassement.

C' est connu:
a^=b;
b^=a;
a^=b;
Mais c'est un artifice d'ecriture: a un moment donne, il y a un registre temporaire d'utilise.
A+,