std::vector<int> buffer = Klasse.construct<std::vector<int>>(/* blabla */)(/* blabla */);

wie müsste die Klasse dafür aussehen?

class aKlasse{
public:
	template<typename T>
	T construct(){
		return T();
	}
};

template <class T>
class CtorProxy
{
public:
    T operator () ()
    {
        return T();
    }
};

class CtorProxyFactory
{
public:
    template <class T>
    CtorProxy<T> construct()
    {
        return CtorProxy<T>();
    }
};

#include <boost/interprocess/managed_shared_memory.hpp> 
#include <iostream> 

int main() 
{ 
  boost::interprocess::shared_memory_object::remove("Highscore"); 
  boost::interprocess::managed_shared_memory managed_shm(boost::interprocess::open_or_create, "Highscore", 1024); 
  int *i = managed_shm.construct<int>("Integer")(99); 
  std::cout << *i << std::endl; 
  std::pair<int*, std::size_t> p = managed_shm.find<int>("Integer"); 
  if (p.first) 
    std::cout << *p.first << std::endl; 
}

managed_shm.find<int>("Integer"); sucht ja im Speicher und gibt irgendwas zurück (keine Ahnung was, soweit habe ich noch nicht gelesen). Also, wie müsste hier boost::interprocess::managed_shared__memory::find aussehen? (Finde die Doku sehr verwirrend).

Class Blah {
public:
   Blah& operator() (Whatever we) 
   {
      // Tue was sinnvolles
      return *this;
   }

   // Ist im Grunde auch nichts anderes als
   Blah& DoSomething (Whatever we)
   {
      // ...
      return *this
   }
   // Könnte man jetzt auch einfach aneinanderhängen:
   // blah.DoSomething(x).DoSomething(y).DoSomething(z);
}

struct ManagebObjectBase
{
    explicit ManagebObjectBase(char const* name) : m_name(name) {}
    virtual ~ManagebObjectBase() {}

    std::string const m_name; // müsste man hier nicht nochmal ablegen, wenn man ne std::map verwendet, aber das nochmal zu ändern ist mir jetzt zu doof
};

template <class T>
struct ManagebObject : ManagebObjectBase
{
    explicit ManagebObject(char const* name) :
        ManagebObjectBase(name),
        m_object() {}

    explicit ManagebObject(char const* name, T const& t) :
        ManagebObjectBase(name),
        m_object(t) {}

    template <class A1>
    ManagebObject(char const* name, A1 const& a1) :
        ManagebObjectBase(name),
        m_object(a1) {}

    template <class A1, class A2>
    ManagebObject(char const* name, A1 const& a1, A2 const& a2) 
        ManagebObjectBase(name),
        m_object(a1, a2) {}

    // ...

    T m_object;
};

std::map<std::string, ManagedObjectBase*> g_objects;

template <class T>
class CtorProxy
{
public:
    explicit CtorProxy(char const* name) : m_name(name) {}

    T* operator () ()
    {
        // vorher sollte man natürlich nochmal checken ob es nicht schon ein objekt mit dem namen gibt,
        // genauso fehlt natürlich das ganze "interprocess" zeugs, aber darum
        // geht's ja hier nicht wenn ich das richtig verstanden habe
        ManagedObject<T>* o = new ManagedObject<T>(m_name.c_str());
        g_objects.insert(std::make_pair(m_name, o));
        return &o.m_object;
    }

    T* operator () (T const& t)
    {
        ManagedObject<T>* o = new ManagedObject<T>(m_name.c_str(), t);
        g_objects.insert(std::make_pair(m_name, o));
        return &o.m_object;
    }

    template <class A1>
    T* operator () (A1 const& a1)
    {
        ManagedObject<T>* o = new ManagedObject<T>(m_name.c_str(), a1);
        g_objects.insert(std::make_pair(m_name, o));
        return &o.m_object;
    }

    template <class A1, class A2>
    T* operator () (A1 const& a1, A2 const& a2)
    {
        ManagedObject<T>* o = new ManagedObject<T>(m_name.c_str(), a1, a2);
        g_objects.insert(std::make_pair(m_name, o));
        return &o.m_object;
    }

    // ...

private:
    std::string const m_name;
};

class CtorProxyFactory
{
public:
    template <class T>
    CtorProxy<T> construct(char const* name)
    {
        return CtorProxy<T>(name);
    }
};

wie find() aussehen müsste sollte jetzt denke ich klar sein.

Wie lang muss man eigentlich C++ programmieren, bis man sowas macht?

Sollte das jetzt ne Provokation sein?