ich möchte in einer Template-Funktion, die eine Factory übergeben kriegt, sowohl die Erzeugung von Stack als auch von Heap-Elementen ermöglichen. Diese Objekte werden dann in einem Vektor gespeichert und verarbeitet. Generell kennzeichne ich die Objektzugehörigkeit von Heap-Objekten durch einen std::unique_ptr und übertrage sie dann in einen boost::vector_ptr.

Deswegen habe ich mir nun folgenden Ansatz überlegt:

#include <memory>
#include <boost/ptr_container/ptr_vector.hpp>

struct Foo{
	Foo(int id) : id(id) {}
	int id;
};

static int counter = 0;

template<typename T>
class TypeInfo{
public:
	typedef std::vector<T> owner_vector;
	static T& remove_ownership(T& t){
		return t;
	}
	static T& dereference(T& t){
		return t;
	}
};

template<typename T>
class TypeInfo<std::unique_ptr<T> >{
public:
	typedef boost::ptr_vector<T> owner_vector;
	static T* remove_ownership(std::unique_ptr<T>& t){
		return t.release();
	}
	static T& dereference(std::unique_ptr<T>& t){
		return *t.get();
	}
};

class HeapFactory{
public:
	typedef std::unique_ptr<Foo> type;
	type create() const{
		return type(new Foo(counter++));
	};
};

class StackFactory{
public:
	typedef Foo type;
	type create() const{
		return Foo(++counter);
	}
};

template<typename TFactory>
void process(const TFactory& factory){
	typedef typename TFactory::type type;
	typedef TypeInfo<type> type_info;
	typedef typename type_info::owner_vector vector_type;
	vector_type vec;
	for(int i=0; i<10; ++i){
		type t = factory.create();
		std::cout << type_info::dereference(t).id << std::endl;
		vec.push_back(type_info::remove_ownership(t));	
	}
	std::cout << vec[4].id << std::endl;
	for(typename vector_type::reference o : vec){
		std::cout << o.id << std::endl;
	}
}

int main(){
	process(HeapFactory());
	process(StackFactory());
}

Würdet ihr es ähnlich machen oder wie würdet ihr es verwirklichen?

Gruß,
XSpille

Ich hab mir deinen Code nicht wirklich angeschaut, aber ich würde es mit einem Allokator machen.

Danke dir EOutOfResources, allerdings versteh ich nicht wie mich das weiterbringen könnte. Ich habe noch nicht wirklich eigene Allokatoren verwendet, aber sie regeln doch afaik 'nur' die Art der Speicherbeschaffung oder sehe ich das falsch?