33 replies to this topic

[Dia]

void swap(int &x, int &y)
{
    x -= y;
    y += x;         // y gets the original value of x
    x = (y - x);    // x gets the original value of y
}

Enjoy testing it out!

[DrunkenCoder]

and don't try swapping a variable with itself...

the code below, have the exact same behaviour.

void swap2(int &x, int &y)
{
	x ^= y ^= x ^= y;
}

[davepermen]

hehe, the much beloved xor..

haven't seen the +- above yet..

but fastest is still with a temp variable.. register actually..

__asm {
mov eax,a
mov ebx,b
mov b,eax
mov a,ebx
}

or possibly there is even some way with mmx? :D

similar there is something for the fu**ing fpu..

but its always fun to swap "mathematically".. without tempvar..

with that idea, people where able to define the radix sort, the only sort faster than the minimum O(n*lg2(n)).. hehe:D

[DrunkenCoder]

smaller (but definatly not faster)

_asm
{
 xchg [a], eax
 xchg [b], eax
 xchg [a], eax
}

but if you're resorting to assembly swaping of variables you're probably
already writing the loop in assembly and trying to hold everything in
registers.

[davepermen]

i never got how xchg really works, but it looks similar to the xor-snippet above :D

any other swap-codes?

[DrunkenCoder]

well, the ones I can think of right now are

push	[a]
push	[b]
pop	[a]
pop	[b]

not very effective and even worse for register only swaps where xchg should
be used, but it's diffrent...

for floats you could use:

fldp [a]
fldp [b]
fxch
fstp [a] 
fstp [b]

using mmx you could use the pshufw instruction family.

[bladder]

davepermen said:

any other swap-codes?

void swap(int& a, int&b )
{
  int c = a;
  a = b;
  b = c;
}

sorry. couldnt resist.

[Mihail121]

Here is a swap performed without a second variable. My creation so hands off!!!!

 

void swap(int *x,int *y)
{
   int second_varible;
   int third_variable;

   // See?! I'm not using the second!!!

  third_variable = *y;
  *y = *x;
  *x = third_variable;
}

[anubis]

:lol: :lol: :lol:

no wait you are serious about your post ?

[davepermen]

hehe

[Smokey97]

lol, i saw this post a few mins after he posted it... and i thought it must have been a joke, so i didnt say anything... but i guess ti isint a joke. :lol: :lol: :lol: :lol:

[Mihail121]

What's wrong with you people? Why do u laugh? Of course i'm serious. Don't u see it works perfecly fine?! I use this one a lot in my projects. Stable and fast and everything. Yep it's cool :D

[anubis]

hospital or police ???

[FarooqMela]

I had something similar sitting around in a header file...
Mine is one line of code though ;-)

inline void
UselessSwap(int& a, int &b)
{
  a -= b += a -= b = -b;
}

[momotaro]

where the hell did u find this one! it is pretty cool!

[Nils Pipenbrinck]

Haha..

What a great thread.. I like the last one.. Never thought about this solution (did anyone tried if it really works?). I also like the function name as it really sais what it's all about.

These "optimizations" are nowadays slower than a temporary variable. But they re cool nevertheless.


I like bit-tricks like these alot.

[roel]

Funny thread indeed, resurrecting old threads isn't always that bad :)

[bladder]

FarooqMela said:

I had something similar sitting around in a header file...
Mine is one line of code though ;-)

inline void
UselessSwap(int& a, int &;)
{
  a -= b += a -= b = -b;
}

Not that I'm whining or anything, but if my understanding is correct about certain aspects of c++, the above code is going straight for the realm of "undefined behavior" in c++.

Someone correct me if I'm wrong.

[.oisyn]

You're wrong

[.oisyn]

Sorry, I was being a bitch :happy:
The reason you're wrong is because the associativity of these expressions is well defined. Just as a + b + c + d is parsed as ((a + + c) + d and std::cout << "hello" << 34 << std::endl is equivalent to ((std::cout << "hello") << 34) << std::endl, this expression becomes a -= (b += (a -= (b = -))

Each = operator returns a reference to *this and is used in the outer expression. The thing that isn't defined is the order of evaluation (which is different from associativity) in the function argument list. ++a = a++ is undefined because that translates to operator=(++a, a++) and the outcome depends on which is evaluated first: ++a or a++.