Re: Order of destructor execution.
As I see, this discussion is done with. I rewrote my code and initial
post as I meant and clarified the question based on the answers I got.
Two questions were answered: the one I actually wanted to ask and
another interesting one due to a typing error.
The typing error was to forget the name of the automatic variable to
be created, leaving the compiler to think that the argument I intended
to use for creation was the name of the object. I wrote
MutexLocker( mut ); //Fails on attempt to create an object named mut
//with default constructor.
//It does not create a temporary.
when I meant:
MutexLocker lock( mut );
where, as said, mut is a global MutexWrapper. The hole post is
rewritten here with comments on the answers, all of them tested.
First the post as I meant:
I have the following classes:
class MutexWrapper
{
public:
MutexWrapper( void ){ pthread_mutex_init( &_mut, NULL ); }
void lock( void ){ pthread_mutex_lock( &_mut ); }
void unlock( void ){ pthread_mutex_unlock( &_mut ); }
~MutexWrapper( void ){ pthread_mutex_destroy( &_mut );}
private:
pthread_mutex_t _mut;
}
class MutexLocker
{
public:
MutexLocker( MutexWrapper& mut ) : _mut( mut ) { mut.lock(); }
~MutexLocker( void ){ _mut.unlock(); }
private:
MutexWrapper& _mut;
}
So that I want to sync acces to the variable
volatile unsigned cont;
Which, by the way, is volatile because I do not want optimization to
mess loops such as while( cont < n );
I hope this answers one of Kanze's questions.
in the following piece of code, supposing there is a global
MutexWrapper mut:
Here was the error in my first post. Whatever that creepy piece of
code meant, it was not what I had in mind. The actual code is:
unsigned getCont( void )
{
MutexLocker lockIt( mut );
return( cont );
}
Will the destructor ~MutexLocker() be executed before the return statement?
Langston got the typing error, but still did not answer to the main
question:
"
By giving the MutexLocker a variable name, its lifetime is the lifetime of
the function/method.
The quesiton still becomes, which is done first, the destruction of LockIt
or the retriving of the cont value? I'm not really sure, someone might
know. But being unsure I would do this.
unsigned getCont( void )
{
MutexLocker LockIt( mut );
unsigned ReturnVal = cont;
return( ReturnVal );
}
"
Which was later answered by Kanze:
"
Conceptually, cont can be copied, as if it had a copy
constructor. The destructor of the variable mut will be called
after this copy.
"
In the same post he also clarifies the "default constructor versus
temporary creation" issue.
How did I test it?
By stepping through the correct code with gdb it becomes clear that
the return( cont ); statement is executed before the destructor for
lockIt.
Trying to compile the code given in my first post with g++ gives:
error: no matching function for call to 'MutexLocker::MutexLocker()'
because it is not defined at all, showing which constructor is
actually called.
Thanks,
Elias.