我创建了一个物理系统来处理任何碰撞对象到任何碰撞对象，如下所示:

namespace Collision
{
    template <typename T, typename U>
    inline void Check(T& t, U& u)
    {
        if(u.CheckCollision(t.GetCollider()))
        {
            u.HitBy(t);
            t.Hit(u);
        }
    }
}

还有其他几个helper objects使其易于使用，但要点是有动态对象需要针对静态对象和其他动态对象进行测试，但静态对象不需要检查。

我想要的是这样的:

void func()
{
    PhysicsWorld world;
    shared_ptr<CSphere> ballPhysics(new CSphere(0,0,ballSprite->Width()));
    BallCommand ballBehavior;
    CBounds bounds(0, 0, 640, 480);
    CBox obstacle(200, 150, 10, 10);

    Collision::Collidable<CBounds> boundC(bounds);
    Collision::Collidable<std::shared_ptr<CSphere>, BallCommand&> ballC(ballPhysics, ballBehavior);
    Collision::Collidable<CBox> obstC(obstacle);

    world.addStatic(boundC);
    world.addDynamic(ballC);
    world.addStatic(obstC);
    ...
    ...
    world.Update();
    ...
    ...
}

我喜欢通过添加函数推断容器，因此使用系统会自动更新类型列表。我想我知道如何使用模板函数生成类型列表，但不知道如何在我需要的地方获取它，或者在编译的什么时候完成。

如果不是这样，那么某些系统使用两个类型列表，然后在内部编写更新函数来遍历所有列表，将它们相互配对。

我读过一些关于 boost MPL 的书，并且读了好几遍 Andrei 的书。但是，我似乎陷入了它的工作原理，并没有真正将其转化为我如何使用它。我希望他们在 MPL 书中有更多关于现实世界示例的部分。

我已经能够让游戏引擎的所有部分与渲染、物理、碰撞(我将检测与 react 分开)、输入、网络、声音等进行交互。所有这些都是通用的方式。现在我只需要以一种通用的方式保存所有的东西。在完成所有这些泛型工作之后，仅仅为了在容器中保存一些东西而要求继承是很愚蠢的，我不想为每个集合可能性编写代码，因为这是泛型编程的一大好处。

我看到 Jalf 表示他/她使用 MPL 做了类似的事情，但没有详细说明让我弄明白。如果有人知道实际使用示例或者我可以从哪里获得有关使用 MPL 的更多信息，我将不胜感激。

再次感谢!

更新

boost MPL 和 boost Fusion 似乎都可以满足我的要求，但是这两个库在现实生活中的良好示例似乎都很少。 MPL 的文档只不过是这个模板做的那样，祝你好运，理解它的含义。 “这是一个例子，但这只是冰山一角!”的融合要好一些!

典型的 boost MPL 示例是 has_xxx。他们在示例中使用了 XXX 和 xxx，因此很难看出 XXX(所需文本)和 Test 或 CheckType 或任何更容易区分的用户类型可以用来代替 xxx 的区别。另外，没有提到这些都不在命名空间中。现在我知道为什么 Scott Meyers 将此与 Psycho 中的淋浴场景进行比较了。

这真的很遗憾，因为我编译和理解的一点点东西确实有用，但很难弄清楚，如果我在运输产品上，我永远不会花这么多精力。

如果有人知道现实世界的例子或更好的引用、解释或教程，我将不胜感激。

更新

下面是更多代码:

template <typename T, typename V = VictimEffect, typename M = MenaceEffect>
class Collidable
{
    T m_Collider;
    V m_HitBy;
    M m_Hit;

public:
    Collidable(T collide, V victim, M menace) : m_Collider(collide), m_HitBy(victim),         m_Hit(menace) {;}
    Collidable(T collide) : m_Collider(collide) {;}
    Collidable(T collide, V victim) : m_Collider(collide), m_HitBy(victim) {;}

    T& GetCollider()
    {
        return m_Collider;
    }

    template <typename V>
    void HitBy(V& menace)
    {
        m_HitBy.HitBy(menace.GetCollider());
    }

    template <typename V>
    void Hit(V& victim)
    {
        m_Hit.Hit(victim.GetCollider());
    }

    template <typename V>
    bool CheckCollision(V& menace)
    {
        return m_Collider.CheckCollision(menace);
    }
};

然后使用它我这样做

    Collidable<Boundary, BallCommand> boundC(boundary, ballBehavior);
    Collidable<CollisionBox> ballC(circle);

然后我需要做的就是对所有主动和被动对象调用我所有主动可碰撞对象的碰撞。

我没有使用 std::function，因为添加函数名称使代码对我来说更清晰。但也许这只是传统思维。

最佳答案

如果我理解正确，你的问题是:

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 处理这两个，提供他们履行契约(Contract)，他们可以用作 f() (其中 f 是相应类型的实例)并且表达式具有类型(可转换为)void .这里的约定是类型删除的编译时方面。

我不打算演示如何实现类型删除，因为有 a great Boostcon 2010 presentation就此主题而言。 (您可以通过链接观看演示文稿和/或获取幻灯片)。或者我(或其他人)可以在评论中做到这一点。

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

关于c++ - 有人可以帮我使用 Boost::MPL 创建一个变量容器吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5787167/