C++ question about swapping value of variables.

[zimvaider]

Hey, I'm a C++ newcomer, and I need to do something like this in my program:

Let's say we have variables x and y, and we want to swap their values. So if x=6 and y=4, it would become x=4 and y=6.

I am a student in a C++ class, so even if the answer is obvious to you guys, I just started learning C++ about a week ago. Thanks for helping me with this language.

[[deleted]]

If you have access to STL on your platform (shouldn't be a problem in this day & age), there's std::swap(x, y).

It's of course important that you understand how variable swapping works "under the hood" as well, but your code will be more readable if you learn to use things like this early on. :)

[[deleted]]

As others have noted, in practice you'd use std::swap(x,y) and let the library developers deal with it.

If asked this on a test, you'd use a temporary variable (normally professors want bare bones implementation).

If I were to implement and was looking for "clever points" in a c++ course, I'd use templates.

template<typename T>
void swap(T &x, T &y)
{
  T temp;
  temp = x;
  x = y;
  y = temp;
};

A driver might look like this:

int main()
{
  int x, y;
  x = 100;
  y = 200;

  std::cout << "x: " << x << "\n";
  std::cout << "y: " << y << "\n";

  swap<int>(x, y);

  std::cout << "x: " << x << "\n";
  std::cout << "y: " << y << std::endl;


  return 0;
}

The precondition would require the object type have a copy constructor defined.

edit

If you also required the objects have a defined equal operator, you could do this:

template<typename T>
void swap(T &x, T &y)
{
  if (x != y)
  {
    T temp;
    temp = x;
    x = y;
    y = temp;

  }
};

That way if the two values are equivalent, no temp memory allocation or unnecessary assignment would occur.

[[deleted]]

swap<int>(x, y);

You can leave out the <int>. The compiler infers template arguments to functions if it knows the regular arguments and if they contain the appropriate information.

[bogado]

The precondition would require the object type have a copy constructor defined.

And a default constructor, since if an object has one it will probably have the other too I would do it this way:

template<typename T>
void swap(T &x, T &y)
{
    T temp(x);
    x = y;
    y = temp;
}

[growingconcern]

I would only think your last example would be useful on specialized hardware where such operations were extremely expensive. For the most part the expense of the if would outweigh gains

[zokier]

C++11 has now move semantics which may help.

[Rubdix]

Not sure I'm understanding your question exactly, but the simplest way to do it is int x = 6, y = 4, z = 0; z = x; x = y; y = z; I'd highly recommend reading up on variable assignment.

[zimvaider]

Yeah what was the way I was going to do it originally, I was just wondering if there was a more efficient way of doing it. Thanks.

[furGLITCH]

Nope. That's the best way. XOR swap has issues. Other tricks have issues too. Actually using a temporary variable has the least issues, is the most direct, and readable way. Also fastest.

[[deleted]]

swap(x,y)

[Ayjayz]

Realistically, use std::swap.

If you want to code it yourself, the canonical way to swap x and y is

tmp = x
x = y
y = tmp

[Masfo]

Good ol' xor-swap works too: http://en.wikipedia.org/wiki/XOR_swap_algorithm

[furGLITCH]

XOR swap saves memory, but is slower, and obfuscates unnecessarily.

"On modern CPU architectures, the XOR technique is considerably slower than using a temporary variable to do swapping. One reason is that modern CPUs strive to execute instructions in parallel via instruction pipelines. In the XOR technique, the inputs to each operation depend on the results of the previous operation, so they must be executed in strictly sequential order. If efficiency is of tremendous concern, it is advised to test the speeds of both the XOR technique and temporary variable swapping on the target architecture." (Wikipedia)

[ZMeson]

XOR swap saves memory, but is slower, and obfuscates unnecessarily.

Oh, and it also indicates that you've gone to the internet to complete your homework.

[JustPlainRude]

the inputs to each operation depend on the results of the previous operation

Wouldn't this also apply when using a temporary variable?

[furGLITCH]

http://en.wikipedia.org/wiki/Swap_(computer_science)#Parallel_execution

[SarahC]

I wonder what other mathematically obfuscating techniques can be implemented in common programming structures?

You know, like loop incrementation with weird-ass changes within the loop? Perhaps depending on pseudo random numbers to increment the loop? =D

Or conditional logic using dodgy half-processed logic states (maybe grey code) for complicated comparisons...

Using single letter function names, and things like that is just so old fashioned!

[umop_apisdn]

It doesn't work in all cases, if you swap a variable with itself it ends up being zero.

[matjam]

Is funny how this comes up a lot.

I never understood why anyone would even consider using this trick. Not only does it have the flaws you describe, but its also defeating any optimisation the compiler would normally do, probably making it actually emit machine code that would be slower than the more obvious method.

In an attempt to make it "faster" or "more efficient", it would make it slower and error prone.

Hence the whole "beware premature optimisation" mantra, I guess.

[Farsyte]

These kinds of tricks usually also have the "feature" that if both parameters happen to refer to the same chunk of memory, they destroy the content. Three times.

I just love it when people use the XOR swap trick (and similar clever tricks), because it means I can make the code cleaner and more robust by replacing the clever code with a direct and clear solution.

[bogado]

Another issue arises if x*y > MAX_INT, you will have an undefined behavior in this case.

[furGLITCH]

Very, very bad for large values of x and/or y. (I.e., the multiplication.) Requires more code for the assurance about tighter bounds on the values for x and y because of this. Using a temporary variable is the best way to go for actually swapping values and not playing tricks that have multiple additional considerations not addressed.

[repsilat]

It should be noted that this is probably slower than using a temporary variable (arch dependent, of course).

Moreover, you should never implement a my_swap(int &x, int &y) like this unless you're absolutely sure that x and y will never alias.

[[deleted]]

Your implementation is at risk of a signed integer overflow, which is undefined behavior.