const volatile???

Discussion in 'C++' started by d.f.s., May 17, 2006.

  1. d.f.s.

    d.f.s. Guest

    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
     
    d.f.s., May 17, 2006
    #1
    1. Advertising

  2. d.f.s. wrote:
    > 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
    --
    Please remove capital 'A's when replying by e-mail
    I do not respond to top-posted replies, please don't ask
     
    Victor Bazarov, May 17, 2006
    #2
    1. Advertising

  3. d.f.s.

    d.f.s. Guest

    [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.

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

    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
     
    d.f.s., May 17, 2006
    #3
  4. d.f.s.

    Marcus Kwok Guest

    d.f.s. <> wrote:
    > 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

    --
    Marcus Kwok
    Replace 'invalid' with 'net' to reply
     
    Marcus Kwok, May 17, 2006
    #4
  5. d.f.s. wrote:
    > [..]
    > 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
    --
    Please remove capital 'A's when replying by e-mail
    I do not respond to top-posted replies, please don't ask
     
    Victor Bazarov, May 17, 2006
    #5
  6. > 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.
     
    Selwyn Alcantara, May 17, 2006
    #6
  7. d.f.s.

    d.f.s. Guest

    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
     
    d.f.s., May 17, 2006
    #7
  8. d.f.s.

    red floyd Guest

    d.f.s. wrote:
    > 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.
     
    red floyd, May 17, 2006
    #8
  9. d.f.s.

    Rolf Magnus Guest

    Victor Bazarov wrote:

    > d.f.s. wrote:
    >> [..]
    >> 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."
     
    Rolf Magnus, May 17, 2006
    #9
  10. d.f.s.

    Phlip Guest

    red floyd wrote:

    > 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...

    --
    Phlip
    http://www.greencheese.us/ZeekLand <-- NOT a blog!!!
     
    Phlip, May 17, 2006
    #10
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. ben
    Replies:
    5
    Views:
    605
    Ulrich Eckhardt
    Jan 11, 2005
  2. Replies:
    11
    Views:
    1,125
  3. Javier
    Replies:
    2
    Views:
    585
    James Kanze
    Sep 4, 2007
  4. 0m
    Replies:
    26
    Views:
    1,146
    Tim Rentsch
    Nov 10, 2008
  5. fungus
    Replies:
    13
    Views:
    902
    fungus
    Oct 31, 2008
Loading...

Share This Page