volatile pointers

[hendrixj]

I was perusing Danny's article (http://www.informit.com/guides/conte...lus&seqNum=345) and was reminded of a question.

I've always used volatile in the context of a pointer: what the pointer points to changes due to other threads. We use something like:
volatile int* ptr=...;

In this case, the value in "ptr" is *not* volatile, rather, the value pointed to by the value in ptr.

One might have a need for:
volatile int my_int;

In which case the value in my_int needs to be volatile.

My confusion is this: how does the compiler know to not optimize *ptr in one case an my_int in another?

Question number two. Would this work:
volatile int& alias_ptr(*ptr);
And the reference be correctly handled?

Thanks

[Danny]

The compiler knows to disable *access optimization through the specific pointer*, not necessarily de-optimize the object itself. Consider a similar example with adding const implicitly:

void func (const string& s);

The string here is treated as const, but it doesn't have to be a true const string:

string mys;
func(mys) //const qualifier implicitly added to string

In your example, when the pointer is declare as pointing to a volatile int, any access through that pointer will not be optimized but when you access the int directly, its value might be optimized by storing a copy thereof in a CPU register.
As for:

volatile int& alias_ptr(*ptr);

You have a reference to a volatile int here. This means that every time you access that int through the reference variable alias_ptr, the int will be treated as a volatile variable. Of course, that doesn't mean that the bound variable becomes volatile. If you access *ptr directly, it might be optimized, so it all boils down to what you want to achieve: treat *ptr as volatile only when accessed via the reference or treat it as volatile all the time.