Thread: Good old 'Swap' function

Unfortunately, in C, that is hard to do, but something like this:

Code:

char *buffer = NULL;
size_t max_size = 0;
void Swap(void *Ptr_A,void *Ptr_B, size_t size)
{
    // Allocate a new buffer when we need a bigger one. Since a big buffer can hold small things, 
    // there's no need to "reduce" the size of the buffer. 
    if (size > max_size)
    {
       free(buffer);
       buffer = malloc(size);
       max_size = size;
    }
    if (buffer == NULL)  // Do some panicing ;
    memcpy(buffer, Ptr_A, size);
    memcpy(PtrA, Ptr_B, size);
    memcpy(Ptr_B, buffer, size);
}

You should of course also free the temporary buffer at some point.

Alternatively, you could use a macro:

Code:

#define SWAP(T, A, B)   do { T temp = (A); (A) = (B); (B) = temp; } while(0)

Use like this:

Code:

struct something 
{
   // stuff here
};

...
   struct something a, b;
   ...
   SWAP(struct something, a, b);

--
Mats

I think the whole point would be to note have to mem copy the data.

No, such copying is necessary. Unless one has a swap function with a pointer to a pointer, one cannot just swap pointers (or rather, one can swap pointers, but there would be no net effect).

The point is to have a swap function that is not restricted to a particular type, like a swap template function in C++.

Say, you want to sort an array of struct widget, then you will need to swap the widgets, and to do that, you need three memcopies. If you have an array of pointer to struct widget, then you can get away with swapping pointers.

--
Mats

Originally Posted by Todd Burch

Yes, I think pointers to pointers are the way to go for speed in these cases.

Yes, that is much better - but assumes the extra overhead of a second table and/or allocating the objects from the heap instead of just using an array. And sometimes the data isn't "yours" to begin with, so you need to sort whatever was given to you "in place" [say for example you are writing a general purpose sort routine].

--
Mats

Originally Posted by Todd Burch

I've thought about this too. Sure would be handy. Something like:

Code:

void Swap(void *Ptr_A, void *Ptr_B)
{
void * Ptr_Temp;
Ptr_Temp= Ptr_A;
Ptr_A=Ptr_B;
Ptr_B=Ptr_Temp;
}

would be nice.

That won't work.
Swapping pointers, however, is easy. In theory, anyway:

Code:

void Swap(void** pA, void** pB)
{
	void** pTemp = pA;
	*pA = *pB;
	*pB = *pTemp;
}

Otherwise, you'll have to use mats's code, since C is lacking support for these kind of things. Much easier in C++, though, since a template function would be all that is required.

Originally Posted by starcatcher

I would like to expand on this function so that it can be used with parameters which are pointers to any type. That is, I would like to create a function that can swap two objects of any type pointed to by two pointers. In the above example only integers can be swapped. What would be the easiest way of doing that?

By switching to C++ and using templates.
Hey, it's the truth - there isn't any easier way!

Right, if you want to use the "swap pointer" method, your code would have to look something like this:

Code:

double dvalues[10] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
double *array[10] = { &dvalues[0], &dvalues[1], &dvalues[2],  &dvalues[3],  &dvalues[4], &dvalues[5], &dvalues[6], &dvalues[7], &dvalues[8], &dvalues[9] };

Swap(&array[3], &array[4]);

Swapping pointers only work if you actually use pointers.

As to which of my methods is faster, it should make very little difference.

--
Mats

Originally Posted by starcatcher

How on earth would I be able to use the swapping pointers
method for something like that?

Swap pointers only works if you're working with pointers. Otherwise you have to use mats's code. C is very limited in this regard. There's no easy or safe method to swap arguments in C. You need C++ for that.

Originally Posted by Elysia

Swap pointers only works if you're working with pointers. Otherwise you have to use mats's code. C is very limited in this regard. There's no easy or safe method to swap arguments in C. You need C++ for that.

And, how does C++ do it "better"?

My macro would work just fine - and in compilers with "typeof" it would even be possible to write it as a simpler macro that doesn't take the type. [Although it still doesn't work on arrays].

--
Mats