Question

I asked this function based on this concept (maybe incorrect?!): Wherever a const can exist, a volatile can exist at the place.

class classA
{
public:
    const int Foo() const;
}

Here the first “const” means the return value is const, we can not change it.
the second const means “Is Query”, this function can not change the member variable and can not call non-const function.

Now comes to volatile: I can understand what volatile does on a variable, like “volatile int a;”
However I have no idea of the difference among the following:

Case 1: The return type is volatile?
volatile void Function1();

Case 2: The function can only call volatile functions? Why add volatile here? Any example?
void Function2() volatile;

Case 3:   Is it valid? If yes, is it simply a combination of Case 1 and Case 2?
volatile void Function3() volatile;

When we put the const at the end of function declaration, it has a beautiful name: “Is Query”
Can you give a decent name/alias to the “volatile” in Case 2?
I mean, whenever we call this name, we can know we are talking about Case 2, not case 1.

Thank you in advance!

Answer 1

Volatile has one primary function, which is to say “STOP! This object is connected to external resources, and thus when I write to it, don’t reorder the write with respect to other volatile reads or writes, and when I read to it, don’t reorder it likewise and don’t optimize these away!”.

To support this, you can put volatile after member functions, which is necessary to call member functions on volatile class objects.

// just a silly example
struct HWOverlayClock {
  HWOverlayClock() { }

  int64_t getTime() volatile const { return timestamp; }

  int64_t timestamp;
};

// imagine we use an implementation defined way to put the
// object at some fixed machine address
volatile const HWOverlayClock clock __attribute__((at_address(0xbabe)));

Putting volatile on a return value can be done too, but it seems to me that it would be less useful since return values are usually temporaries and volatile semantics are quite on the the opposite scale of temporaries. Putting volatile on void is particularly nonsensical (const and volatile are ignored if put at the top-level of a return type if the type is not a class type (i.e at the right of a * if it is a pointer), because these return values do not correspond to memory, likely being kept in registers by implementations too). Putting volatile on non-toplevel for references or pointers can be useful, like in the following

struct Controller {
    HWOverlayClock volatile const* getClock() const { return clock; }

private:
    volatile const HWOverlayClock *clock;
};

Hope it helps.