What is the purpose of a volatile
member function in C++?
Constant and volatile member functions (C++ only) A nonconstant member function can only be called for a nonconstant object. Similarly, a member function declared with the volatile qualifier can be called for volatile and nonvolatile objects. A nonvolatile member function can only be called for a nonvolatile object.
Member functions are operators and functions that are declared as members of a class. Member functions do not include operators and functions declared with the friend specifier. These are called friends of a class. You can declare a member function as static ; this is called a static member function.
The const member functions are the functions which are declared as constant in the program. The object called by these functions cannot be modified. It is recommended to use const keyword so that accidental changes to object are avoided. A const member function can be called by any type of object.
To answer the question about what it means to have a 'volatile member function' (which may or may not be what was originally intended by the person who posted the question), marking a member function as const
or volatile
(or a combined const volatile
) applies those qualifiers to the this
pointer used in the function. As stated by the standard (9.2.1 "The this
pointer"):
The type of this in a member function of a
class X
isX*
. If the member function is declaredconst
, the type of this isconst X*
, if the member function is declaredvolatile
, the type ofthis
isvolatile X*
, and if the member function is declaredconst volatile
, the type of this isconst volatile X*
.
So by marking the member function as volatile
you'd be making any access to the non-static data members of the object within that member function as volatile
.
EDIT:
This answer was posted when the question was about the volatile keyword. Question seems to have been changed by a third party.
ORIGINAL:
Volatile informs the compiler that it should not assume that the value it just put in the variable marked as volatile will be there next time it uses it... that it must check the current value before using it again.
One example is if the variable represents a memory location that might be changed by another process.
Here's an example (been ages since I did C++ so please forgive any minor syntax issues):
volatile int x; int DoSomething() { x = 1; DoSomeOtherStuff(); return x+1; // Don't just return 2 because we stored a 1 in x. // Check to get its current value }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With