const volatile???

[d.f.s.]

In the post below, 'copy constructor?', the answers refer to
an object declared as const volatile. Now I'm confused.
Are those terms not mutually exclusive?

const='Hey compiler! This is not going to change so generate
your code based on that assumption.'

volatile='Hey compiler! This is going to change so generate
your code based on that assumption.'

Or am I out to lunch on my understanding of these two words?

Drew

 

[Victor Bazarov]

In the post below, 'copy constructor?', the answers refer to
an object declared as const volatile. Now I'm confused.
Are those terms not mutually exclusive?

Definitely not.

const='Hey compiler! This is not going to change so generate
your code based on that assumption.'

No, that's not all. OOH, it could be "hey, it's not going to change",
OTOH it could just as well be "*you* are not [allowed] to change it".

volatile='Hey compiler! This is going to change so generate
your code based on that assumption.'

Or am I out to lunch on my understanding of these two words?

Not completely, but you're making wrong assumptions and conclusions.

V

 

[d.f.s.]

[snip]

const='Hey compiler! This is not going to change so generate
your code based on that assumption.'

No, that's not all. OOH, it could be "hey, it's not going to change",
OTOH it could just as well be "*you* are not [allowed] to change it".

Right. It is a promise the coder makes , which the compiler will
enforce upon anyone who writes code to handle the object. It
protects the object & -used to be- helps the compiler to optimize
its' output. I think that I've got that one.
My understanding of 'volatile':
A key word which indicates that an object is likely to be
or WILL be modified. Redundant for objects not
declared const. Was used to help older compilers to
do optimization. Sort of like 'register', it is seldom used
or needed with modern compilers.

I assume that my understanding of 'volatile' is wrong.

Drew

 

[Marcus Kwok]

My understanding of 'volatile':
A key word which indicates that an object is likely to be
or WILL be modified. Redundant for objects not
declared const. Was used to help older compilers to
do optimization. Sort of like 'register', it is seldom used
or needed with modern compilers.

I assume that my understanding of 'volatile' is wrong.

Here's an article by Andrei Alexandrescu on the 'volatile' keyword:

volatile - Multithreaded Programmer's Best Friend
http://www.ddj.com/showArticle.jhtml?articleID=184403766

 

[Victor Bazarov]

[..]
My understanding of 'volatile':
A key word which indicates that an object is likely to be
or WILL be modified. Redundant for objects not
declared const.

No, it's not.

Was used to help older compilers to
do optimization. Sort of like 'register', it is seldom used
or needed with modern compilers.

I assume that my understanding of 'volatile' is wrong.

Yes, but not entirely. 'volatile' indicates an object that can change
by means other than the program in which it appears. It could be some
address that a device (through a driver or DMA means) can update based
on a change of its state (serial port receives another input, etc.)

Declaring a variable 'volatile' makes the compiler generate code that
reads the value from the variable's storage any time it's needed in
an expression, precluding the compiler from caching the value or some
other optimization WRT the variable's value.

V

 

[Selwyn Alcantara]

My understanding of 'volatile':

> A key word which indicates that an object is likely to be
> or WILL be modified. Redundant for objects not
> declared const. Was used to help older compilers to
> do optimization. Sort of like 'register', it is seldom used
> or needed with modern compilers.

I assume that my understanding of 'volatile' is wrong.

You understood correctly (as in, it's wrong). 'volatile' isn't simple a
cute way of saying "not const". It informs the compiler that it
shouldn't expect to know whether the variable changes or not based on
what it compiles. This is used when you make a variable point to an
area of memory for example. In practice, this means that the program
has to recheck the variable every time it's used rather than apply some
sly optimization because it sees you yourself didn't change it in the
code.

 

[d.f.s.]

Ok. So a good example would be:
const volatile clock;

const in that YOU are not allowed to change it.
volatile in that it will change so look at it whenever
CheckTime() is called.

If right, thank you all

Drew

 

[red floyd]

Ok. So a good example would be:
const volatile clock;

const in that YOU are not allowed to change it.
volatile in that it will change so look at it whenever
CheckTime() is called.

Exactly.

const is "This code is not allowed to modify this variable.
volatile is "This variable may change due to forces unrelated to this code".

Example:

const volatile unsigned long * const MEMORY_MAPPED_REG =
reinterpret_cast<const volatile unsigned long *>(0xFFE00000L);

MEMORY_MAPPED_REG is a read only h/w register at FFE00000. It
can't be written to, but may change due to external issues.

 

[Rolf Magnus]

[..]
My understanding of 'volatile':
A key word which indicates that an object is likely to be
or WILL be modified. Redundant for objects not
declared const.

No, it's not.

Was used to help older compilers to
do optimization. Sort of like 'register', it is seldom used
or needed with modern compilers.

I assume that my understanding of 'volatile' is wrong.

Yes, but not entirely. 'volatile' indicates an object that can change
by means other than the program in which it appears.

Or that it may be read by something else than that program.

It could be some address that a device (through a driver or DMA means) can
update based on a change of its state (serial port receives another input,
etc.)

Declaring a variable 'volatile' makes the compiler generate code that
reads the value from the variable's storage any time it's needed in
an expression,

And also writing it.

precluding the compiler from caching the value or some other optimization
WRT the variable's value.

volatile is quite commonly used in low-level code that communicates directly
with memory-mapped hardware registers or when transfering data into/out of
an interrupt routine. In this case, it's important that any read and write
operation is guaranteed to be actually performed. It boils down to: "The
as-if rule is not enough."

 

[Phlip]

Example:

const volatile unsigned long * const MEMORY_MAPPED_REG =
reinterpret_cast<const volatile unsigned long *>(0xFFE00000L);

MEMORY_MAPPED_REG is a read only h/w register at FFE00000.  It
can't be written to, but may change due to external issues.

The canonical example here is the system clock...