Re: [boost] Assigning values without knowing type

From: Jens Maurer (Jens.Maurer_at_[hidden])
Date: 2001-01-28 17:56:18

Here are a few initial comments.  They should not discourage you, but
point out a few things for your further consideration.

jbandela_at_[hidden] wrote:
> Here is some code, that allows assigning and manipulating variables
> without knowing the exact type, but by knowing what expression
> produced them.

In general, the STL approach to that problem is by defining another
function call layer where the unknown type is a template parameter.
It is deduced during overload resolution, and the type of the
argument expression is thus "known" (rather instantiated) in the
function body.  I do, however, recognize that it would be useful
to avoid that additional layer in some circumstances.  Unfortunately,
the examples exposed are not template-heavy enought to really show
the benefit, which would possibly become more apparent when
expressions yield very complicated types, as those in expression
templates.

 - Please separate implementation (header file) from test/example program.
 - The whole thing needs boost-ification and documentation.
 - I'd like to see a feature comparison between this proposal and
the (boost-accepted) "any" class by Kevlin Henney.

> class Destructor{};

Needs a virtual destructor, I believe.
 
> template<class T>
> struct DestructorImp:public Destructor

Should be in namespace "boost::detail" and be referenced from the
"Memento" class internally.

>                 std::allocator<T> a;
>                 a.destroy(static_cast<T*>(o));

Is there any benefit from using std::allocator<> instead
of calling the destructor explictly right away, such as so:
  static_cast<T*>(o)->~T()
?

> template<class T>
> DestructorImp<T> GetDestructor(void* o, const T*){

The "const T*" parameter is superfluous, you can use explicit function
template instantiation.  Yes, MSVC is broken in this regard, but
can be worked around.

> template<int sz>
> struct Memento{
>         char mem_[sz];
>         void* data_;
> 
>         template<class T>
>         Memento(const T& object){
>                 T* o = new(static_cast<void*>(&mem_[0])) T(object);
>                 data_ = o;

_data will always contain &mem_[0] and is thus superfluous.

You need to cater for alignment requirements, which you don't currently.

> #define BOOST_TYPE(expr) (0?GetType((expr)):0)

Boost has been very reluctant in defining new function-style macros.  Any
such macro needs a strong justification that its purpose cannot be fulfilled
with "normal" C++, e.g. templates.  I'd like to see  this justification
explicitly.
 
> #define BOOST_LET(var, expr,line) Memento<sizeof(expr)> var
> (expr);Destructor dd##line = GetDestructor(var.data_,BOOST_TYPE
> (expr)) ;

This is entirely unsatisfactorily, because it interferes with
conditional statements not containg a block.

  if( /* ... */ )
    BOOST_LET(...);  // oops

Besides, the destruction can be integrated in Memento and then, I
believe, looks suspiciously like the "any" class.

Plus, explicitly requiring a "line" parameter is too error-prone.

>         for(;y.get(BOOST_TYPE(v.begin())) != v.end();++y.get
> (BOOST_TYPE(v.begin())) )

This looks rather awkward to me, compared to a simple typedef
and a straightforward loop.

It would be really helpful if, given some expression "expr", the
type of this expression could be made available as a name, so
that
  typedef BOOST_TYPE(2.0*3) T;
gives you "double" for T.

This is why we need "typeof" in the core language.

Jens Maurer