Question

I was reading about volatile member function and came across an affirmation that member function can be both const and volatile together. I didn’t get the real use of such a thing. Can anyone please share their experience on practical usage of having member function as const and volatile together.

I wrote small class to test the same:

class Temp { public:      Temp(int x) : X(x)     {     }      int getX() const volatile     {         return X;     }      int getBiggerX()     {         return X + 10;     } private:     int X; };  void test( const volatile Temp& aTemp) {     int x = aTemp.getX(); }  int main(int argc, char* argv[]) {     const volatile Temp aTemp(10);     test(aTemp);      return 0; } 

Answer 1

You asked for a practical example of volatile member functions. Well i can’t think of one because the only situations i could imagine are so low-level that i would not consider using a member function in the first place, but just a plain struct with data-members accessed by a volatile reference.

However, let’s put a const volatile function into it just for the sake of answering the question. Assume you have a port with address 0x378h that contains 2 integers, 4 bytes each. Then you could write

struct ints {     int first;     int second;     int getfirst() const volatile {         return first;     }      int getsecond() const volatile {         return second;     }       // note that you could also overload on volatile-ness, just like       // with const-ness };  // could also be mapped by the linker.  ints const volatile &p = *reinterpret_cast<ints*>(0x378L); 

You are stating

I’m not changing them, but another thing outside this abstract semantics could change it. So always do a real load from its address.

Actually, volatile signals that the value of an object might not be the value last stored into it but is actually unknown and might have been changed in between by external (not observable by the compiler) conditions. So when you read from a volatile object, the compiler has to emulate the exact abstract semantics, and perform no optimizations:

a = 4; a *= 2;    // can't be optimized to a = 8; if a is volatile because the abstract   // semantics described by the language contain two assignments and one load. 

The following already determines what volatile does. Everything can be found in 1.9 of the Standard. The parameters it talks about are implementation defined things, like the sizeof of some type.

The semantic descriptions in this International Standard define a parameterized nondeterministic abstract machine. This International Standard places no requirement on the structure of conforming implementations. In particular, they need not copy or emulate the structure of the abstract machine. Rather, conforming implementations are required to emulate (only) the observable behavior of the abstract machine as explained below. […]

A conforming implementation executing a well-formed program shall produce the same observable behavior as one of the possible execution sequences of the corresponding instance of the abstract machine with the same program and the same input. […]

The observable behavior of the abstract machine is its sequence of reads and writes to volatile data and calls to library I/O functions.