Is there any built in swap function in C which works without using a third variable?
10 Answers
No.
C++ builtin swap function: swap(first,second);
Check this:
You can use this to swap two variable value without using third variable:
a=a^b;
b=a^b;
a=b^a;You can also check this:
How to swap without a third variable?
3Why do you not want to use a third variable? It's the fastest way on the vast majority of architectures.
The XOR swap algorithm works without a third variable, but it is problematic in two ways:
- The variables must be distinct i.e.
swap(&a, &a)will not work. - It is slower in general.
It may sometimes be preferable to use the XOR swap if using a third variable would cause the stack to spill, but generally you aren't in such a position to make that call.
To answer your question directly, no there is no swap function in standard C, although it would be trivial to write.
4Assuming you want a C solotion, not a C++ one, you could make it a macro, at least using GCC extension to have it generic enough, something like
#define SWAP(x,y) do { \ typeof(x) _x = x; \ typeof(y) _y = y; \ x = _y; \ y = _x; \ } while(0)beware of tricks like invocations swap(t[i++],i); to avoid them, use the address operator &. And you'll better use a temporary (for integers, there is a famous and useless trick with exclusive-or).
PS: I'm using two local variables _x and _y (but I could have used one local variable only) for better readability, and perhaps also to enable more optimizations from the compiler.
There is no such function in standard C.
(In C++ you have std::swap().)
Maybe a macro from this question can be useful for you.
0There is no standard function in C to swap two variables.
A macro can be written this way:
#define SWAP(T, a, b) do { T tmp = a; a = b; b = tmp; } while (0)and the macro can be called this way:
int a = 42;
int b = 2718;
SWAP(int, a, b);Some solutions for a writing a SWAP macro should be avoided:
#define SWAP(a, b) do { a = b + a; b = a - b; a = a - b; } while (0)when operands are of signed types an overflow can occur and signed overflow are undefined behavior.
Also a solution trying to optimize the XOR solution like this should be avoid:
#define SWAP(a, b) (a ^= b ^= a ^=b)a is modified twice between the previous and the next sequence point, so it violates the sequence points rules and is undefined behavior.
Since you may copy any object representation into an unsigned char array in C, the following macro allows you to swap any two objects:
#define SWAP(X,Y) \ do { \ unsigned char _buf[sizeof(*(X))]; \ memmove(_buf, (X), sizeof(_buf)); \ memmove((X), (Y), sizeof(_buf)); \ memmove((Y), _buf, sizeof(_buf)); \ } while (0)GCC will even generate optimal code for this in some cases. You might not keep your job though...
4There is is a C++ library function. It swaps the values of two integer variables. For example, swap(x, y); will swap the values of variables x and y. Similarly, swap(mat[i][j], mat[j][i]); will swap two values in matrix mat, namely the value in row i column j and the value in row j column i.
1#define swap(T, x, y) \ { \ T tmp = x; \ x = y; \ y = tmp; \ }
int main()
{ int a = 10; int b = 20; printf("a=%d b=%d\n", a, b); swap(int, a, b); printf("a=%d b=%d\n", a, b); return 0;
}There is no built-in swap function but you can try this
a = a ^ b;
b = a ^ b;
a = b ^ a;
I believe I've come up with a type-agnostic function for swapping any two values in standard C, though since I'm fairly new to the language I may have overlooked something. It uses the XOR swap algorithm, and I'm sure it could be optimized more, but it works as long as the two values point to the same number of bytes, specified by the 3rd argument:
void swapn(void *a, void *b, size_t n) { if (a == b) { return; } size_t i; char *x = (char *)a, *y = (char *)b; for (i = 0; i < n; i++) { *x ^= *y; *y ^= *x; *x ^= *y; x++; y++; }
}Example usage:
// swap two integers
int x = 5, y = 30;
printf("%d\t%d\n", x, y);
swapn(&x, &y, sizeof(int));
printf("%d\t%d\n\n", x, y);
// swap two floats
float a = 9.23f, b = 6.83f;
printf("%.2f\t%.2f\n", a, b);
swapn(&a, &b, sizeof(float));
printf("%.2f\t%.2f\n\n", a, b);
// swap two doubles
double p = 4.7539, q = 0.9841;
printf("%.4f\t%.4f\n", p, q);
swapn(&p, &q, sizeof(double));
printf("%.4f\t%.4f\n\n", p, q);
// swap two chars
char m = 'M', n = 'n';
printf("%c\t%c\n", m, n);
swapn(&m, &n, sizeof(char));
printf("%c\t%c\n\n", m, n);
// swap two strings of equivalent length
char s[] = "Hello", t[] = "World";
printf("%s\t%s\n", s, t);
swapn(s, t, sizeof(s));
printf("%s\t%s\n\n", s, t);The output is:
5 30
30 5
9.23 6.83
6.83 9.23
4.7539 0.9841
0.9841 4.7539
M n
n M
Hello World
World Hello
