Re: Locking arbitrary resources without creating objects on the heap (longish)
Greg Herlihy wrote:
Kai-Uwe Bux wrote:
The requirement put forth by the OP is that one lock type shall work for
all resource types, i.e., the OP specifically wanted to be able to say:
class resource1 {
public:
void lock() {std::cout << "resource1::lock()\n";}
void unlock() {std::cout << "resource1::unlock()\n";}
};
class resource2 {
public:
void lock() {std::cout << "resource2::lock()\n";}
void unlock() {std::cout << "resource2::unlock()\n";}
};
int main()
{
{
resource1 res1;
resource2 res2;
{
lock l(res1);
}
{
lock l(res2);
}
}
}
I see, the multiple resource type requirement does complicate the
implementation. But it is nonetheless still possible to implement a
typesafe, stack-based solution. I would question the wisdom of
implementing such a class; after all, there must differences among the
different resource classes - so the program would probably be better
off in finding out what those differences are - and respecting them -
rather than to assume that they must be unimportant.
Here are a few details about the solution below: the first step was to
define an abstract base class to provide a unified locking interface
for all lockable types. The next step was to subclasses this abstract
class with a class template to call the lock and unlock methods for the
appropriate resource type. And the last step was to have StLocker's
constructor determine the class type of the resource being managed. By
making StLocker's constructor a function template, there was no longer
any need for StLocker itself to be a class template:
#include <iostream>
// Abstract base class for locking interface
struct Lockable
{
virtual ~Lockable() {}
virtual void lock() = 0;
virtual void unlock() = 0;
};
// class template implementing locking
template <class T>
struct TLockable : public Lockable
{
public:
TLockable(T& t) : t_(&t) {}
virtual void lock()
{
t_->lock();
}
virtual void unlock()
{
t_->unlock();
}
private:
T * t_;
};
// Stack-based locking class for multiple types
struct StLocker
{
public:
// the specific lockable type
template <class T>
Note the new() in the following line. So how is this solution "stack-based"?
StLocker(T& t) : mLock(new TLockable<T>(t))
{
mLock->lock();
}
~StLocker() { mLock->unlock(); }
Should there be a
delete mLock;
somewhere?
private:
Lockable * mLock;
};
class resource1
{
public:
void lock() { std::cout << "resource1::lock()\n";}
void unlock() { std::cout << "resource1::unlock()\n";}
};
class resource2
{
public:
void lock() { std::cout << "resource2::lock()\n";}
void unlock() {std::cout << "resource2::unlock()\n";}
};
int main()
{
resource1 res1;
resource2 res2;
{
StLocker lockMe(res1);
}
{
StLocker lockMe(res2);
}
}
// Program Output:
resource1::lock()
resource1::unlock()
resource2::lock()
resource2::unlock()
That's all nice, but I think this is more or less variation of the OP's
reference implementation, and it suffers from the same flaw -- it uses
new():
I have been thinking about this for a while and had a hard
time to come up with a solution. It's easy to setup something
that involves a dynamic object. Here's an outline of this:
class lock {
private:
struct locker_base {
virtual ~locker_base() {}
};
template< typename T >
struct locker : public locker_base {
locker(const T& obj) : obj_(obj) {}
~locker() {obj_.unlock();}
const T& obj_;
};
public:
template< typename T >
lock(const T& obj) : locker_(new locker<T>(obj) {}
~lock() {delete locker_;}
private:
locker_base* locker_;
};
The class 'lock::locker<T>' would store a reference to the
resource object and call the resource's 'unlock()' function
in its dtor.
This works, but has the disadvantage of creating an object
on the heap -- which might be OK for most resources, but
for some (de-)allocation/deallocation might dominate the
(un-)locking run-time.
This whole exercise is before us, because the OP wanted a solution that does
no dynamic memory allocations.
However, I would be more interested in your use of the word "typesafe" in
this context. In which sense is your lock class more typesafe than the
class provided by the OP or more typesafe than mine:
class lock {
template < typename T >
static
void unlock_ptr ( void * t_ptr ) {
( reinterpret_cast< T* >( t_ptr ) )->unlock();
}
void * t_ptr;
void ( *unlock_fct ) ( void * );
lock ( lock const & );
lock& operator= ( lock const & );
public:
template < typename T >
lock ( T & t )
: t_ptr ( reinterpret_cast< void* >( &t ) )
, unlock_fct ( &unlock_ptr<T> )
{
t.lock();
}
~lock ( void ) {
unlock_fct( t_ptr );
}
}; // lock
Also, I wonder whether making copy-constructor and assignment operator
private is a good idea or whether one should have them transfer ownership
like auto_ptr.
Best
Kai-Uwe Bux
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]