Boost logo

Boost :

From: Beman Dawes (bdawes_at_[hidden])
Date: 2002-01-13 16:54:48

At 05:39 AM 1/13/2002, Andrei Alexandrescu wrote:

>I think a good solution would be the following.
>The policies might take two template arguments, the last one being the
>SmartPtr class itself. In turn, SmartPtr exposes all of its policies
>typedefs. Here's a trimmed-down example.
>template <
> class T,
> template <class, class> class Checking>
> template <class, class> class Storage>
>class SmartPtr
> : public Checking< T, SmartPtr<T, Checking, Storage> >
> : public Storage< T, SmartPtr<T, Checking, Storage> >
> typedef Checking checking_policy;
> typedef Storage storage_policy;
> ...
>So now the policies that don't care of each other simply ignore their
>template parameter. Policies that do need to communicate with
>policies can access them by using the parent class and their named
>This is cool as long as we're working with static functions. If needed, a
>static_cast could access the parent object as well. (I'd prefer something
>better than that.)

Yes, agreed. This is the approach Peter Dimov has been advocating. But I
can't get it to compile with either GCC 3.0.1 or VC++7.0b2. See code below.

GCC says:

policy_ptr.cpp: In instantiation of `default_checking<int, policy_ptr<int,
default_checking, default_storage> >':
policy_ptr.cpp:37: instantiated from `policy_ptr<int, default_checking,
policy_ptr.cpp:37: instantiated from here
policy_ptr.cpp:34: no type named `storage_policy' in `class policy_ptr<int,

    default_checking, default_storage>'

line 34 is the line that reads: void check(
typename SmartPtr::storage_policy::pointer_type p ) const

Any ideas?


// try Andrei's and Peter's ideas

#include <cassert>

template < class T,
            template < class, class > class Checking,
            template < class, class > class Storage
class policy_ptr
   : public Checking< T, policy_ptr< T, Checking, Storage > >,
     public Storage< T, policy_ptr< T, Checking, Storage > >
   typedef Checking< T, policy_ptr<T, Checking, Storage> > checking_policy;
   typedef Storage< T, policy_ptr<T, Checking, Storage> > storage_policy;

template < class T, class SmartPtr >
class default_storage
   typedef T* pointer_type;
   T* get()
     { static_cast<SmartPtr const *>(this)->check( pointee_ ); return
pointee_; }
   T* pointee_;

template < class T, class SmartPtr >
class default_checking
   void check( typename SmartPtr::storage_policy::pointer_type p ) const
     { assert( p ); }

policy_ptr< int, default_checking, default_storage > my_ptr;

Boost list run by bdawes at, gregod at, cpdaniel at, john at