有人可以帮助我创建一个变量容器使用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的想象延伸)。还有一种替代方法，我认为它更合适、更简洁、更易于维护:类型擦除。(该技术的名称可能有点不幸，第一次可能会误导。)

类型删除的一个很好的例子是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的契约。这里的契约是类型擦除的编译时方面。

我不打算演示如何实现类型擦除，因为在2010年的Boostcon上有一个很好的关于这个主题的演讲。(你可以观看演示和/或通过链接获取幻灯片)。或者我(或其他人)可以在评论中做。

最后需要说明的是，类型擦除的实现(通常)使用动态多态性。我提到这一点是因为我注意到您考虑将类型列表用作存储为manager成员的运行时对象。这闻起来像穷人的反射，真的，穷人的动态多态性。所以请不要这样做。如果您指的是MPL计算结果中的类型列表，则忽略节点。

这是不完整的，我没有得到我想要的一切，但现在已经足够好了。我正在输入整个解决方案，以防它对其他人有所帮助。

#include <boostmplvector.hpp>
#include <boostmplfold.hpp>
#include <boostmplfor_each.hpp>
#include <boostmplinherit.hpp>
#include <boostmplinherit_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容器，它包含了应该保存的类型。

我认为这为扩展提供了一个很好的起点，但涵盖了元编程的大部分内容。