Why is a point-to-volatile pointer, like “volatile int * p”, useful?

by

A pointer of the form

volatile int* p;

is a pointer to an int that the compiler will treat as volatile. This means that the compiler will assume that it is possible for the variable that p is pointing at to have changed even if there is nothing in the source code to suggest that this might occur. For example, if I set p to point to a regular integer, then every time I read or write *p , the compiler is aware that the value may have changed unexpectedly.

There is one more use case for a volatile int*: If you declare an int as volatile, then you should not point at it with a regular int*. For example, this is a bad idea:

volatile int myVolatileInt;
int* ptr = &myVolatileInt; // Bad idea!

The reason for this is that the C compiler no longer remembers that the variable pointed at by ptr is volatile, so it might cache the value of *ptr in a register incorrectly. In fact, in C++, the above code is an error. Instead, you should write:

volatile int myVolatileInt;
volatile int* ptr = &myVolatileInt; // Much better!

Now, the compiler remembers that ptr points at a volatile int, so it won’t (or shouldn’t!) try to optimize accesses through *ptr.

One last detail – the pointer you discussed is a pointer to a volatile int. You can also do this:

int* volatile ptr;

This says that the pointer itself is volatile, which means that the compiler shouldn’t try to cache the pointer in memory or try to optimize the pointer value because the pointer itself might get reassigned by something else (hardware, etc.) You can combine these together if you’d like to get this beast:

volatile int* volatile ptr;

This says that both the pointer and the pointee could get changed unexpectedly.The compiler can’t optimize the pointer itself, and it can’t optimize what’s being pointed at.

Hope this helps!

More Related Contents:

  1. How do pointer-to-pointers work in C? (and when might you use them?)
  2. Create a pointer to two-dimensional array
  3. Pointers in C: when to use the ampersand and the asterisk?
  4. Is NULL always zero in C?
  5. What does the ‘array name’ mean in case of array of char pointers?
  6. What is an opaque pointer in C?
  7. What is the reason for using a double pointer when adding a node in a linked list?
  8. Post-increment on a dereferenced pointer?
  9. constant pointer vs pointer on a constant value [duplicate]
  10. What exactly is a C pointer if not a memory address?
  11. What exactly is meant by “de-referencing a NULL pointer”?
  12. Reversing a string in C
  13. Why do I need to use type** to point to type*?
  14. What does malloc(0) return? [duplicate]
  15. Meaning of “referencing” and “dereferencing” in C
  16. Pass a two dimensional array to a function of constant parameter
  17. Should one really set pointers to `NULL` after freeing them?
  18. Explain this implementation of malloc from the K&R book
  19. using printf to print out floating values
  20. Confusion regarding modification of const variable using pointers
  21. What are function pointers used for, and how would I use them?
  22. What’s a modern term for “array/pointer equivalence”?
  23. How to check if a pointer is valid? [duplicate]
  24. Doesn’t a 2D array decay to pointer to pointer
  25. Array of size 0 at the end of struct [duplicate]
  26. Dereference void pointer
  27. How to check if a pointer is freed already in C?
  28. Returning a struct pointer
  29. Casting void pointers
  30. Cast T[][] to T*

Leave a Comment