如何查找，object是由哪些Types組成的？

Question

好的，昨天我在這里發布了幾乎相同的問題，但我無法根據我的需要修改答案（工作）......我不想弄亂另一個話題，所以我開始了新的話題。

所以，我有 2 個（實際上大約 15 個）結構，它們可以組成一個 object

class MyBase{};

template <typename Super, typename T1, typename T2> 
struct A : public Super 
{
    void doStuffA() { cout<<"doing something in A"; }
};

template <typename Super, typename T1, typename T2> 
struct B : public Super 
{
    void doStuffB() { cout<<"doing something in B"; }
};

然后我有：

template <typename ComposedType, typename T1, typename T2>
class Combined
{
    ComposedType m_cT;
public:
    Combined(const ComposedType & c) : m_cT(c) { }

    typedef A<null, T1, T2> anull;
    typedef B<null, T1, T2> bnull;

    void update()
    {
        typedef typename split<ComposedType>::Ct Ct;
        typedef typename split<ComposedType>::At At;

        //this I want 
        if( composed of A ) 
            m_cT.doStuffA();

        if( composed of B ) 
            m_cT.doStuffB();
    }
};

我想像這樣使用它：

int main()
{
    typedef A<B<MyBase,int,int>,int,int> ComposedType1;
    typedef B<MyBase,int,int> ComposedType2;

    ComposedType1 ct1;
    ComposedType2 ct2;

    Combined<ComposedType1, int, int> cb1(ct1);
    cb1.update();

    Combined<ComposedType2, int, int> cb2(ct2);
    cb2.update();
}

（整數僅用於示例目的）

所以我有一些模板魔法：

struct null{};

template<typename> 
struct split
{
    typedef null Ct;
    typedef null At;
};

template<template<typename> class C, typename T> 
struct split<C<T> >
{
    typedef C<null> Ct; //class template 
    typedef T      At;  //argument type
};

template<template<typename> class C> 
struct split<C<MyBase> >
{
    typedef C<null> Ct; //class template 
    typedef MyBase   At;  //argument type
};

但我不能讓它工作:(

我知道有很多代碼，但這實際上是最小的示例...我已將此代碼發布到ideone ，以使其更好地閱讀。

謝謝！

編輯：（在評論中提問）

我正在為 AI 構建系統，並希望在編譯時盡可能多地解決問題。 在這種情況下，我正在構建運動行為系統。 我的代碼提供了許多類型的行為，如“前往點”、“避開”、“避開障礙物”等。這些行為在上面的示例中被稱為 A a、B。每個行為都有類似“performBehavior”的方法及其返回類型可以與其他“performBehavior”組合。

所以我想在編譯時把特定的行為放在一起。 例如。 只是 A 或 A+C+D+F 等...

然后在我的更新中執行以下操作：

如果行為由“Go to point”組成，則比“performBehaviorGoTo”

如果行為由“Evade from”組成，則比“performBehaviorEvade”

...

這是非常簡短的解釋，但希望我已經表達了我的觀點

Answer 1

您可以通過 function 重載來做到這一點：

template <typename Super, typename T1, typename T2> 
void doStuff(A<Super, T1, T2>& a) { a.doStaffA(); }

template <typename Super, typename T1, typename T2> 
void doStuff(B<Super, T1, T2>& b) { b.doStaffB(); }

接着：

// ...
void update()
{
    //this I want 
    //if( composed of A ) 
    //    m_cT.doStuffA();
    //if( composed of B ) 
    //    m_cT.doStuffB();

    doStuff(m_cT);
}

目前尚不清楚，是否要鏈接A<B<...> >調用。 如果你這樣做，那么類似以下的事情會做：

template <class T> 
void doStuff(T&) { /* do nothing */ }

template <typename Super, typename T1, typename T2> 
void doStuff(A<Super, T1, T2>& a) { 
    a.doStaffA(); 
    doStuff(static_cast<Super&>(a)); 
}

template <typename Super, typename T1, typename T2> 
void doStuff(B<Super, T1, T2>& b) { 
    b.doStaffB(); 
    doStuff(static_cast<Super&>(b)); 
}