🚀 go-pugleaf

Ok, time for my submission to this old thread.
My approach to a (generic) swap routine is that is must be reentrant
(no static buffers here!) and also should not dynamically allocate memory.
So we swap in place. Byte for byte (or char for char). It compiles cleanly
with gcc-2.7.2 (but gcc is not THE benchmark for STDC-compliant programs,
I know that).

---Programs follows---
#include <assert.h>
#include <stdio.h>
#include <stddef.h>

#define SWAP(a, b) memswap(&(a), &(b), sizeof(a))

static void
memswap(void *_a, void *_b, register size_t size)
{
	if (_a != _b)
	{
		register char *a = _a;
		register char *b = _b;
		/* Assert that objects don't overlap. */
		assert(a + size <= b || b + size <= a);
		for (; size != 0; size--, a++, b++)
		{
			register int c = *a;
			*a = *b;
			*b = c;
			/* This loop could be optimized, for instance by checking
			   for suitable alignment of a and b pointers and copying
			   larger units instead of bytes. */
		}
	}
}

int main()
{
	double x = 1.0, y = 2.0;
	printf("before swap: x = %f, y = %f\n", x, y);
	SWAP(x, y);
	printf("after swap:  x = %f, y = %f\n", x, y);
	return 0;
}
---Program ends---

Mufsi:tmp> gcc -g -Wall -ansi -pedantic swap.c -o swap
Mufsi:tmp> swap
before swap: x = 1.000000, y = 2.000000
after swap:  x = 2.000000, y = 1.000000
Mufsi:tmp>

	Ola Liljedahl
	olli@enea.se
	"OSE - Design on a higher level"