Printable View
This is what I have is as follows:
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?Code:void Swap(int *Ptr_A,int *Ptr_B)
{
int Ptr_Temp;}
Ptr_Temp=*Ptr_A;
*Ptr_A=*Ptr_B;
*Ptr_B=Ptr_Temp;
Instead of pointers-to-int, you could use pointers-to-void (and you'd have to malloc space yourself for the temporary); however, you would then need to pass in to your function the size of the data objects, and use memcpy to copy.
I've thought about this too. Sure would be handy. Something like:
would be nice.Code:void Swap(void *Ptr_A, void *Ptr_B)
{
void * Ptr_Temp;
Ptr_Temp= Ptr_A;
Ptr_A=Ptr_B;
Ptr_B=Ptr_Temp;
}
Unfortunately, in C, that is hard to do, but something like this:
You should of course also free the temporary buffer at some point.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);
}
Alternatively, you could use a macro:
Use like this:Code:#define SWAP(T, A, B) do { T temp = (A); (A) = (B); (B) = temp; } while(0)
--Code:struct something
{
// stuff here
};
...
struct something a, b;
...
SWAP(struct something, a, b);
Mats
I think the whole point would be to not have to mem copy the data.Quote:
Originally Posted by tabstop
However, I suspect it might not be a simple as I would like. That's because it's not just the pointer to the area that pointer represents, but also the amount of memory that has been allocated, so free() can work too.
Todd
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).Quote:
I think the whole point would be to note have to mem copy the data.
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
Yes, I think pointers to pointers are the way to go for speed in these cases.Quote:
Originally Posted by matsp
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].Quote:
Originally Posted by Todd Burch
--
Mats
That won't work.Quote:
Originally Posted by Todd Burch
Swapping pointers, however, is easy. In theory, anyway:
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.Code:void Swap(void** pA, void** pB)
{
void** pTemp = pA;
*pA = *pB;
*pB = *pTemp;
}
By switching to C++ and using templates.Quote:
Originally Posted by starcatcher
Hey, it's the truth - there isn't any easier way!
Thank you everyone!
I had a bit of trouble understanding the swapping pointers method at first,
but now I think I have an idea how it works. If I have this (in the main
function of course...):
The thing is though, that afterwards a and b haven't actually been swapped,Code:
double a=1.23,b=2.34,*ap,*bp;
ap=&a;
bp=&b;
Swap((void **) &ap,(void **) &bp);
void Swap(void **App,void **Bpp)
{void **Cpp=App;
*App = *Bpp;
*Bpp = *Cpp;}
only ap and bp (as expected), and so I can't use the variables a and b until I
do something like a=*ap,b=*bp in the main function again. Wouldn't it have
been better just to use matsp's method(s)? Are there cases you can think of
where just swapping the pointers is all that is required?
Also, would this work? Would this swap the two elements in the array?
That looks REALLY suspect to me. How would you do it otherwise though with the Array?Code:double Array[2];
Swap((void **) &Array,(void **) &(Array+1))
What this is all getting at, is as somebody correctly guessed, a general purpose
bubblesort. How on earth would I be able to use the swapping pointers
method for something like that?
I will try the two of Matsp's methods. Which one would you say is quicker?
Thanks in advance!;)
Right, if you want to use the "swap pointer" method, your code would have to look something like this:
Swapping pointers only work if you actually use pointers.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]);
As to which of my methods is faster, it should make very little difference.
--
Mats
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.Quote:
Originally Posted by starcatcher
And, how does C++ do it "better"?Quote:
Originally Posted by Elysia
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