Re: code pattern for locking & unlocking

On 30.11.2010 13:17, Martin B. wrote:


I suppose get() will be inlined (if it's called in the same compilation
unit).

If you don't use the >restriction< no global optimization and activate
(which is by default activated) global optimization/link time code
generation all functions will be inlined.

Additionally if you use a wrapper function to handle the code part to be
locked, I would assume it to be nearby the function calling it.
Therefore it will be inline in most of the cases.

Back to a comparable C# using example, which is also a good example of
C++ compiler optimization:

As mentioned in other posts lambda functions could be used, to simulate
the C# using syntax:

For the ones which are not familiar with C#: Keyword >using< is some
kind of C# RAII:

void foo()
{
   using (Object o = new Object())
   {
   } // end of block
}

Ensures, that o.Dispose() is called at the end of the block or if an
exception occurs. Dispose() can be "roughly compared" to a kind of
resource-destructor (doesn't free memory however).

This could be simulated in C++
(similar examples have been already posted)

E.g.:

#include <functional>

class Mutex
{
public:
    void Lock() { printf("Locked\r\n"); }
    void Unlock() { printf("Unlocked\r\n"); }
};

class AutoLock
{
public:
    AutoLock (Mutex& mInit) : m(mInit) { m.Lock(); }
    ~AutoLock() { m.Unlock(); }

    Mutex& m;
};

template<typename F>
void LockScope(Mutex& m, const F& call) { AutoLock a(m); call(); }

int main(int argc, char* argv[])
{
    Mutex mutex;

    LockScope(mutex, []()
    {
       printf("DoStuff");
    });
    return 0;
}

The C++ compiler (in this case VC++ default release config settings)
optimizes and compiles this code to the equivalent of:

   printf("Locked");
   printf("DoStuff");
   printf("Unlocked");


Andre

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]