Pointers with the & symbol

Three of the following have the same value. Which value of the following is different?
a. *&Ptr
b. &*Ptr
c. *Ptr
d. Ptr


In the books that i have the only ones presented are a,c , d. I read that the asterisk is to tell that its a pointer. The & is a dereference for the address. But I have never seen B. Is B the memory address of a pointer?
Is D just a variable?

All of the alternatives show something that is (at least) an rvalue. As the question states, three of them have the same value, a fourth one is different. D is "the value of the pointer itself".

--
Mats

So D is the value of the pointer
C is a pointer itself
A is pointer to the memory address of pointer

I unerstand that D is the different one, but what is B or is B even legal?

but B
a. *&Ptr
b. &*Ptr
c. *Ptr
d. Ptr

They are all legal.

The following compiles without warning in gcc with -Wall -Wextra -pedantic -ansi - of course, it would not show the correct value of the pointers if it was on a 64-bit machine, as int is only 32-bit, so the cast "looses" the upper part of the pointer.

Code:

---

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int *ptr = malloc(sizeof(int));
    *ptr = 42;
   
    printf("%d\n", (int)&*ptr);
    printf("%d\n", (int)*&ptr);
    printf("%d\n", (int)*ptr);
    printf("%d\n", (int)ptr);

    return 0;
}

---

--
Mats

what you just said just went right over my head. I tried to put compile it on my windows vista machine using Dev C++ and it said "Invalid conversion from void to int"

Quote:

---

Originally Posted by Emeighty

what you just said just went right over my head. I tried to put compile it on my windows vista machine using Dev C++ and it said "Invalid conversion from void to int"

---

Probably because you are compiling it as C++ - I'm sorry, I posted C code in a C++ forum. Quick fix - insert the following in place of the existing malloc line:

Code:

---

    int *ptr = (int *)malloc(sizeof(int));

---

Edit: Complete C++ example:

Code:

---

#include <iostream>

int main()
{
    int *ptr = new int;
    *ptr = 42;
   
    std::cout << reinterpret_cast<int>(&*ptr) << std::endl;
    std::cout << reinterpret_cast<int>(*&ptr) << std::endl;
    std::cout << reinterpret_cast<int>(*ptr) << std::endl;
    std::cout << reinterpret_cast<int>(ptr) << std::endl;

    return 0;
}

---

--
Mats

Thanks alot for the help, really appreciate it.

Quote:

---

Originally Posted by Emeighty

I read that the asterisk is to tell that its a pointer. The & is a dereference for the address.

---

Not exactly.
* and & have different meaning depending on how they're used.
If they're used when declaring a variable, like this:

Code:

---

int num;
int* pInt;
int& rInt = num;

---

The first is a regular int, the second is creating a pointer to an int, and the third is creating a reference to an int.
But if used like this:

Code:

---

cout << *pInt;
cout << &num;

---

The first is de-referencing a pointer to get the actual value of the int, and the second is getting the address of the num variable (i.e. getting a pointer to it).

The funny thing is that C++ allows you to stack these operators. And if you do, you might get them to "cancel out" each other.

Say &*p.
Dereference p, then take its address. Basically if we call p level 1, then *p becomes level 0 and then &p becomes level 1 again. So it's kind of pointless to do that, but it's possible.

*&p is another neat one. The result is the address stored in the pointer.
Basically, the p is level 1. Apply & and you get level 2, which is the address of the pointer, T**. Then dereference the pointer to pointer and it becomes level 1 again, the pointer, T*.

Quote:

---

So it's kind of pointless to do that, but it's possible.

---

It's useful when p is a smart pointer and you want the real address.

Note that in the first post, it's actually C that's the odd one out. Furthermore, a and d are completely identical, whereas b is slightly different in that it's an rvalue, not an lvalue. The difference? Well, it's rather complicated, but for example, you can apply address-of to an lvalue, but not an rvalue.

d: ptr -> &ptr = valid
a: *&ptr -> &*&ptr = valid
b: &*ptr -> & &*ptr = invalid (parsing issue aside - note that I put a space between the two ampersands)