Может ли кто-нибудь помочь мне создать контейнер переменных с помощью Boost::MPL?

Если я правильно понимаю, ваша проблема:

class manager {
public:
    template<typename T>
    void add(T t);

private:
    /* ??? */ data;
    /* other members? */
};

manager m;
some_type1 s1;
some_type2 s2;
m.add(s1);
m.add(s2);
/* m should hold its copies of s1 and s2 */

где some_type1 и some_type2 не связаны между собой, и вы не хотите переделывать их для использования динамического полиморфизма.

Я не думаю, что MPL или Fusion сделают то, что вы хотите, с этой формой. Если ваша проблема заключается в том, какой контейнер использовать в качестве члена PhysicsWorld, то никакие вычисления во время компиляции не помогут: тип члена определяется во время создания экземпляра, то есть строка manager m;.

Вы можете переписать менеджер в стиле метапрограммирования, чтобы использовать его следующим образом:

typedef manager<> m0_type;
typedef typename result_of::add<m0_type, some_type1>::type m1_type;
typedef typename result_of::add<m1_type, some_type2>::type final_type;
/* compile-time computations are over: time to instantiate */
final_type m;
/* final_type::data could be a tuple<some_type1, some_type2> for instance */
m.add(s1); m.add(s2);

Это действительно то, с чем может помочь MPL+Fusion. Однако это по-прежнему остается довольно привязанным к миру времени компиляции: можете ли вы представить себе написание template<typename Iter> void insert(Iter first, Iter last) только для того, чтобы вы могли копировать содержимое контейнера в менеджер?

Позвольте мне предположить, что ваши требования таковы, что на самом деле manager должен использоваться гораздо более оперативно, как в моей первоначальной формулировке вашего вопроса. (Я не думаю, что это сильное воображение для PhysicsWorld). Есть альтернатива, которую я считаю более подходящей, гораздо менее многословной и более удобной в сопровождении: type-erasure. (Название метода может быть немного неудачным и может ввести в заблуждение в первый раз.)

Хорошим примером стирания типов является std::function:

std::function<void()> func;
func = &some_func; /* this just looks like that internally std::function stores a void(*)() */
func = some_type(); /* but here we're storing a some_type! */

Стирание типов — это метод соединения времени компиляции со временем выполнения: в обоих приведенных выше назначениях аргументы являются несвязанными типами (один из которых не является классом, поэтому даже отдаленно не полиморфен во время выполнения), но std::function обрабатывает оба, при условии выполнения контракта, что они могут использоваться как f() (где f – экземпляр соответствующего типа) и что выражение имеет тип (преобразуемый в) void. Контракт здесь — это аспект стирания типов во время компиляции.

Я не собираюсь демонстрировать, как реализовать стирание типов, потому что есть отличная презентация Boostcon 2010 по теме. (Вы можете посмотреть презентацию и/или получить слайды по ссылке). Или я (или кто-то другой) могу сделать это в комментариях.

И последнее замечание: реализация стирания типов (обычно) использует динамический полиморфизм. Я упомянул об этом, потому что заметил, что вы рассматривали использование списков типов как объекта времени выполнения, хранящегося как член manager. Это пахнет отражением бедняка, и действительно, динамическим полиморфизмом бедняка. Так что не делай этого, пожалуйста. Если вы имели в виду списки типов как результат вычисления MPL, то игнорируйте узел.

Это не полное И я не получил всего, что хотел, но пока этого достаточно. Я ввожу все решение на случай, если оно поможет другим.

#include <boost\mpl\vector.hpp>
#include <boost\mpl\fold.hpp>
#include <boost\mpl\for_each.hpp>
#include <boost\mpl\inherit.hpp>
#include <boost\mpl\inherit_linearly.hpp>
#include <iostream>
#include <vector>

using namespace boost::mpl::placeholders;

typedef boost::mpl::vector<short, long, char, int> member_types;

template <typename T>
struct wrap
{
    std::vector<T> value;
};

typedef boost::mpl::inherit_linearly<member_types, boost::mpl::inherit<wrap<_2>, _1> >::type Generate;

class print
{
    Generate generated;

public:
    template <typename T>
    void operator()(T)
    {
        std::cout << *static_cast<wrap<T>&>(generated).value.begin() << std::endl;
    }

    template <typename T>
    void Add(T const& t)
    {
        static_cast<wrap<T>&>(generated).value.push_back(t);
    }
};

void main()
{
    print p;

    short s = 5;
    p.Add(s);
    long l = 555;
    p.Add(l);
    char c = 'c';
    p.Add(c);
    int i = 55;
    p.Add(i);

    boost::mpl::for_each<member_types>(p);
}

Это не последний объект, который мне нужен, но теперь у меня есть все части, чтобы сделать то, что я хочу.

Обновить

И, наконец, я получаю это.

template <typename TL>
class print
{
    template <typename T>
    struct wrap
    {
        std::vector<T> value;
    };

    typedef typename boost::mpl::inherit_linearly<TL, boost::mpl::inherit<wrap<_2>, _1> >::type Generate;
    Generate generated;

public:
    void Print()
    {
        boost::mpl::for_each<TL>(*this);
    }

    template <typename T>
    void operator()(T)
    {
        std::cout << *static_cast<wrap<T>&>(generated).value.begin() << std::endl;
    }

    template <typename T>
    void Add(T const& t)
    {
        static_cast<wrap<T>&>(generated).value.push_back(t);
    }
};

Здесь TL — это контейнер boost::mpl, какие типы нужно хранить.

Я думаю, что это обеспечивает хорошую отправную точку для расширения, но охватывает большую часть частей метапрограммирования.

Надеюсь, это поможет другим.