Re: Question on using volatile in a return type

Hello all,

actually I am asking as well about semantics and best practices...

To start with, I am waiting on a condition variable (in a loop that is).
The actual condition is a bool flag located elsewhere, which is
to be passed in as a function parameter. So the correct type would be
"volatile bool&"

void func1 (volatile bool& flag) {
        // init...

        while (!flag && !err)
                err = pthread_cond_wait (&cond, &mutex)=

        // ...

}

The "volatile" should give the compiler a hint not to employ optimisation=

but fetch the value from the original location, where it may have been ch=

by another thread meanwhile -- is this correct?

And: does the flag referred to have to be declared as volatile at the ori=

location? (usually somewhere in a class?). Or is it sufficient to define =

reference as volatile bool& ?

Now, assumed I want to use a functor instead of the bool flag.
What would be the correct and the "best" way to define it?

class Check1 {
        bool operator() () { ... }

}

class Check2 {
        volatile bool operator() () { ... }

}

class Check3 {
        volatile bool& operator() () { ... }

}

My understanding is that for Check3 the "volatile" is necessary, is this
correct? But Check1 should be ok, because it's returning a value and it w=

actually be re-invoked in each loop iteration?

And besides, would you consider the definition within Check2 good practic=

bad practice, expressive, superfluous, ....?