Ich habe eine Klasse compound_t. Diese ist intern ein std::vector. Als letztes Element wird immer ein Objekt des typs next_t angehängt. Das soll am besten implizit geschehen und nicht jedes mal das Objekt per Parameterliste übergeben werden müssen. Und zweitens soll es sich immer um die selbe Instanz handeln um Speicher zu sparen. Somit kann ich das Objekt nicht erst im Konstruktor erstellen. Es muss von Außen kommen. Das widerspricht sich ein wenig.

Ich bin jetzt schon auf die Idee gekommen eine Fabrikklasse zu schreiben, die eine Instanz von next_t hält und diese bei der Konstruktion immer überreicht.

Also so,

class compund_factory_t
{
private:

  virtual_machine_t &vm;
  next_t next;

public:

  compound_factory_t(virtual_machine_t &vm)
   : vm(vm), 
     next(vm)
  { }

  template<typename ... args_t>
  compound_t operator()(args_t ... args)
  {
     return compound_t(vm, next, args ...);
  }
};

int main()
{
 ...
  compund_factory_t make_compound(vm);
  compound_t compound1 = make_compound( ... );
  compound_t compound2 = make_compound( ... ); 
 ...
}

Vorsicht. Code nicht getestet! Wollte nur das Prinzip verdeutlichen. Was haltet ihr davon? Habt ihr vielleicht eine Besser Lösung parat?

Danke,
Martin

ich weiß zwar nicht, was du vor hast, aber möchtest du einfach eine Factory,
der du einmal die Parameter übergibst und dann nur noch create aufrufst?

Wahrscheinlich lieg ich völlig falsch, aber vielleicht willst du sowas:

#include <utility> 
#include <tuple>
#include <boost/type_traits/remove_const.hpp>

struct Foo{

	Foo(int i, char c){}
};

template<unsigned int I, typename Type, typename... TParams>
struct factory_helper{

	template<typename TTuple, typename... TParams2>
	static Type create_instance(TTuple& tuple, TParams2... params){
		typedef typename std::tuple_element<I-1, typename boost::remove_const<TTuple>::type >::type forward_type;
		return factory_helper<I-1, Type, TParams...>::template create_instance<TTuple, forward_type, TParams2...>(tuple, std::get<I-1>(tuple), params...);
	}

};

template<class Type, typename... TParams>
struct factory_helper<0, Type, TParams...>{
	typedef std::tuple<TParams...> tuple_type;

	template<typename TTuple, typename... TParams2>
	static Type create_instance(TTuple& tuple, TParams2... params){
		return Type(params...);
	}
};

template<class Type, typename... TParams>
class factory{
private:
public:
	factory(TParams... params) : _params(params...) {}

	Type operator()() const{
		return factory_helper<sizeof...(TParams), Type, TParams...>::create_instance(_params);
	}

private:
	std::tuple<TParams...> _params;
};

template<typename Type, typename... TParams>
static factory<Type, TParams...> create_factory(TParams... params){
	return factory<Type, TParams...>(params...);
}

int main() 
{ 
	auto factory = create_factory<Foo>(1,'c');
	Foo foo = factory();
}

Gruß,
XSpille