Re: "Value class instance" pattern?

[Benjamin Thaut]

I had the very same problem and I'm using a composite helper struct for 
this purpose:

struct DefaultCtor {}; //call default ctor type
struct composite(T)
{
  static assert(is(T == class),"can only composite classes");
  void[__traits(classInstanceSize, T)] _classMemory = void;
  bool m_destructed = false;
  debug {
    T _instance;
  }
  else
  {
    @property T _instance()
    {
      return cast(T)_classMemory.ptr;
    }

    @property const(T) _instance() const
    {
      return cast(const(T))_classMemory.ptr;
    }
  }

  alias _instance this;

  @disable this();
  @disable this(this); //prevent evil stuff from happening

  this(DefaultCtor c){
  };

  void construct(ARGS...)(ARGS args) //TODO fix: workaround because 
constructor can not be a template
  {
    _classMemory[] = typeid(T).init[];
    T result = (cast(T)_classMemory.ptr);
    static if(is(typeof(result.__ctor(args))))
    {
      result.__ctor(args);
    }
    else
    {
      static assert(args.length == 0 && !is(typeof(T.__ctor)),
                    "Don't know how to initialize an object of type "
                    ~ T.stringof ~ " with arguments:\n" ~ ARGS.stringof 
~ "\nAvailable ctors:\n" ~ ListAvailableCtors!T() );
    }
    debug _instance = result;
  }

  void destruct()
  {
    assert(!m_destructed);
    Destruct(_instance);
    debug _instance = null;
    m_destructed = true;
  }

  ~this()
  {
    if(!m_destructed)
    {
      Destruct(_instance);
      m_destructed = true;
    }
  }
}


I and I use it often (especially with containers, I always tend to 
forget newing containers, which can not happen with this helper struct 
because of @disable this();

Usage is something like the following:

class Foo
{
  int m_i;
  this()
  {
    m_i = 5;
  }

  this(int i)
  {
    m_i = i;
  }
}

class Bar
{
  composite!Foo m_foo;

  this()
  {
    m_foo = typeof(m_foo)();
    m_foo.construct(DefaultCtor()); // would call Foo.this()
    // alternative
    m_foo.construct(5); // would call Foo.this(int)
  }
}

I wrote this before constructors of structs could be templated, I plan 
on updating it so you can write

m_foo = typeof(m_foo)(5);

The m_destructed member is kind of optional, if the default destruction 
order is ok, you can omit it and save the additional bytes of overhead 
it imposes. A advantage is also that Foo is a normal class, you can 
inherit from it and you don't have to write any boilerplate code to use 
the value type of Foo.