🚀 go-pugleaf

In article <30FCDA77.69CB@trilogy.com>,
D. Allan Drummond <allan.drummond@trilogy.com> wrote:
[an example and discussion about type dereferencing removed]
>I really want to write something like this (the following code is
>nonsensical but should convey the spirit of the idea):
>
>template<class Container>
>void deep_copy( Container& from, Container& to )
>{
>    to = from; // expand to make sure TO is as big as FROM.
>               // should be cheap, if this is really a list of pointers.
>    Container::const_iterator f( from.begin() );
>    Container::iterator t( to.begin );
>
>    while( (f != from.end()) && (t != to.end()) && *f )
>        *t++ = new (*Container::value_type)( **f++ );
>}
>
>It seems as though there's no REAL reason to have to split it into two
>functions, but the "type dereferencing" is crucial.

Well, you can generalize the type deferencing scheme using a partial
specialization:

template <class T> class type_dereferencer
{
};

template <class T>
class type_dereferencer<T*>
{
public:
  typedef T base_type;
};

Of course you would also have to specialize for user-defined
pointer types and STL iterators.

Now you can use
type_dereferencer<Container::value_type>::base_type in place of 
(*Container::value_type) in your example.

And if typedef templates were allowed, you could use a slightly better
syntax:

template <class T>
typedef type_dereferencer<T>::base_type type_dereference;
--
   Esa Pulkkinen                        | C++ programmers do it virtually
   E-Mail:  esap@cs.tut.fi              | everywhere with a class, resulting
   WWW   :  http://www.cs.tut.fi/~esap/ | in multiple inheritance.




[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]