Swapping Pointers to pointers in C

Question

I have a question which involves calling a function with 2 parameters of a pointer to a pointer

int main(void)
{ ...
int *ptrp = &p, *ptrq = &q;
int **ppp = &ptrp, **ppq  = &ptrq;
swap_ptr(ppp,ppq);/* &ptrp, &ptrq passed */ 
/* to swap_ptr() */
return 0;
}

void swap_ptr(int **ptrA,int **ptrB)...

We have to swap the values of ptrp and ptrq, so does that mean in the swap_ptr function I just use *ptrA and *ptrB to swap them or is it some other pointer statement?

Thanks

You have the answer in your question, so I'm not exactly sure why it needed to be asked... — Michael Burr
– Michael Burr, Commented Apr 2, 2012 at 5:06
@0x69 Fun fact: If you XOR swap two pointers that are the same, then they will both be set to a NULL pointer. — Corbin
– Corbin, Commented Apr 2, 2012 at 6:55
@Corbin It depends on what you mean "same pointers". If it means same pointer variable - then yes, you can't swap same var - XOR swap must be applied to two variables which are stored at different memory addresses. However if by saying "same pointers" you mean different pointer variables which points to the same address - then NO, you can perfectly swap these two pointers. For example - below code is 100% valid in terms of XOR swap applicability => — Agnius Vasiliauskas
– Agnius Vasiliauskas, Commented Apr 2, 2012 at 7:57
void xorSwap (int **x, int **y) { if (x != y) { *x = (int*)((int)*x ^ (int)*y); *y = (int*)((int)*x ^ (int)*y); *x = (int*)((int)*x ^ (int)*y); } } int main(void){ int a = 7; int b = 11; int * pa = &b; int * pb = &b; printf("before %p %p / %d %d\n", pa, pb, *pa, *pb); xorSwap(&pa, &pb); printf("after %p %p / %d %d\n", pa, pb, *pa, *pb); return 0; } — Agnius Vasiliauskas
– Agnius Vasiliauskas, Commented Apr 2, 2012 at 7:59

Corbin · Accepted Answer · 2012-04-02 05:03:16Z

3

It's the same concept as swapping anything:

void swap(int* a, int* b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

In this case, you just happen to be swapping int* instead of int:

void swap(int** a, int** b)
{
    int* tmp = *a;
    *a = *b;
    *b = tmp;
}

answered Apr 2, 2012 at 5:03

Corbin

33.6k7 gold badges73 silver badges79 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

AusCBloke · Accepted Answer · 2012-04-02 05:02:35Z

0

Yes, *ptrA would refer to the variable ptrp in main and *ptrA would refer to ptrq. Swap these two values as you would for any other type and ptrp will now point to q and ptrq to p.

Since this sounds like it might be homework I'll let you come up with the three lines of code.

answered Apr 2, 2012 at 5:02

AusCBloke

18.6k6 gold badges44 silver badges45 bronze badges

1 Comment

nain33 Over a year ago

Thanks a lot, that's all I needed to know

Chris · Accepted Answer · 2012-04-02 05:03:00Z

0

*ptrp refers to the value that the pointer is pointing to. ptrp refers to the value of the pointer (the memory location)

swap_ptr could simply store one of the values in a tmp var and then swap the values.

answered Apr 2, 2012 at 5:03

Chris

4,1035 gold badges36 silver badges51 bronze badges

Comments

ozanmuyes · Accepted Answer · 2013-12-24 00:28:16Z

I'm kind of new with these algorithms/techniques but I've had came up with this function;

function swap(int *p1, int *p2) {
  *p1 = *p1 + *p2;
  *p2 = *p1 - *p2;
  *p1 = *p1 - *p2;
}

You can test this function like that;

int a = 10;
int b = 20;

printf("%d %d\n", a, b); // 10 20

swap(&a, &b);

printf("%d %d\n", a, b); // 20 10

Here's a 3-step explanation for better understanding;

*p1 = *p1 + *p2;
Add the values coming from p1 (*p1=10) and p2 (*p2=20) and store result on p1 (*p1=30).
*p2 = *p1 - *p2;
We know result of the addition, calculate the old value of p1 by subtracting current value of p2 (current *p2=20) from value coming from p1 (*p1=30) and store result on p2 (calculated *p2=10).
*p1 = *p1 - *p2;
Since the value of p1 (*p1=30) did not change on step 2 and we still have the old value of p1 on p2 (*p2=10), we can divide p2 into p1 and store the result on p1 (calculated *p1=20)

So as you can see we swapped two ints without defining any temporary variable and making pass-by-reference function call.

The reason of pass-by-reference is to minimize usage of memory. Because every pass-by-value call allocates new variables on the memory (to be deleted by GC or not) depends on how much parameter you've passed to the function.

-1 This is a very dangerous way to swap values, as explained in stackoverflow.com/questions/20753278/…
@JoeHass Why it is dangerous? As you can see in Update 1 there is no any problem with maximum value of int. What is the reason causing dangerous situation of swap() function?
You demonstrated that it would work once, which is much different from demonstrating that it will always work. Have you checked to see what the C language standard has to say about what happens when a signed integer overflows?

Collectives™ on Stack Overflow

Swapping Pointers to pointers in C

4 Answers 4

Comments

1 Comment

Comments

3 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

1 Comment

Comments

3 Comments

Linked

Related