选择零件执行C++的策略

首先让我展示几个类：

class globalcontext
{
  public:
  /*partA context*/
  A;
  B;
  c;
  /*partB context*/
  D;
  E;
  F;
  .......
  execute();  //a method to do something (serialize) for context above

};

class mainprocess
{
     callsubprocess();
};
class subprocessA{};
class subprocessB{};
class subprocessC{};
..................

实际上，有几个后端在运行主进程，因此上下文将从这里或那里发送，这就是我想要执行序列化/取消序列化的原因

流程类似于：mainprocess:：callsubprocess-->选择一个子流程，因此从globalcontext类中选择subprocessA-->执行上下文的一部分

---

可以在boost中使用factory吗

也许你在寻找一种战略模式？假设A-F编码行为，您可以“混合”不同的行为或将其作为策略提供：

注意：下面，静态/非静态成员函数之间的分隔稍微有点随意，混合可以很好地包含静态成员

混血儿 策略

---

执行globalcontext的一部分是什么意思？你在寻找战略模式吗？这个问题对我来说没什么意义…我不明白你的意思。具体地说，选择子流程？如果这是给定的，那么为什么不调用subprocessA呢？因为对于所有的上下文，都应该在一个类中存储和执行，subprocess只能获取上下文。因为我想将整个上下文集中在一个地方，所以这个地方将负责序列化/取消序列化上下文，子流程可以从中获得。@sehe您能帮我回答另一个问题吗，很抱歉再次打扰您。非常感谢你的帮助。谢谢你的回答，我编辑了我的问题，你可以看到；嘿，对不起我的解释，我清楚地给出了一个想法。它在问题/12977753/using-boost-factory-to-products-on-demands-c中

#include <iostream>

struct NormalPartABehaviour {
    void A() { std::cout << "Normal A" << std::endl; }
    void B() { std::cout << "Normal B" << std::endl; }
    void C() { std::cout << "Normal C" << std::endl; }
};

struct SpecialPartABehaviour {
    void A() { std::cout << "Special A" << std::endl; }
    void B() { std::cout << "Special B" << std::endl; }
    void C() { std::cout << "Special C" << std::endl; }
};

struct NormalPartBBehaviour {
    void D() { std::cout << "Normal D" << std::endl; }
    void E() { std::cout << "Normal E" << std::endl; }
    void F() { std::cout << "Normal F" << std::endl; }
};

template <typename PartAMixin, typename PartBMixin>
struct GlobalContext : public PartAMixin, public PartBMixin
{
};

///// test method:

template <class Context>
void test(Context globalcontext)
{
    globalcontext.A();
    globalcontext.B();
    globalcontext.C();
    globalcontext.D();
    globalcontext.E();
    globalcontext.F();
}

int main()
{
    GlobalContext<NormalPartABehaviour,  NormalPartBBehaviour> ctx1;
    GlobalContext<SpecialPartABehaviour, NormalPartBBehaviour> ctx2;

    std::cout << "testing ctx1: \n";
    test(ctx1);
    std::cout << "testing ctx2: \n";
    test(ctx2);
}

testing ctx1:
Normal A
Normal B
Normal C
Normal D
Normal E
Normal F
testing ctx2:
Special A
Special B
Special C
Normal D
Normal E
Normal F

#include <iostream>

struct NormalPartABehaviour {
    static void A() { std::cout << "Normal A" << std::endl; }
    static void B() { std::cout << "Normal B" << std::endl; }
    static void C() { std::cout << "Normal C" << std::endl; }
};

struct SpecialPartABehaviour {
    static void A() { std::cout << "Special A" << std::endl; }
    static void B() { std::cout << "Special B" << std::endl; }
    static void C() { std::cout << "Special C" << std::endl; }
};

struct NormalPartBBehaviour {
    static void D() { std::cout << "Normal D" << std::endl; }
    static void E() { std::cout << "Normal E" << std::endl; }
    static void F() { std::cout << "Normal F" << std::endl; }
};

template <typename PartAMixin, typename PartBMixin>
struct GlobalContext
{
    static void A() { PartAMixin::A(); }
    static void B() { PartAMixin::B(); }
    static void C() { PartAMixin::C(); }

    static void D() { PartBMixin::D(); }
    static void E() { PartBMixin::E(); }
    static void F() { PartBMixin::F(); }
};

///// test method:

template <class Context>
void test()
{
    Context::A();
    Context::B();
    Context::C();
    Context::D();
    Context::E();
    Context::F();
}

int main()
{
    typedef GlobalContext<NormalPartABehaviour,  NormalPartBBehaviour> ctx1;
    typedef GlobalContext<SpecialPartABehaviour, NormalPartBBehaviour> ctx2;

    std::cout << "testing ctx1: \n";
    test<ctx1>();
    std::cout << "testing ctx2: \n";
    test<ctx2>();
}

testing ctx1: 
Normal A
Normal B
Normal C
Normal D
Normal E
Normal F
testing ctx2: 
Special A
Special B
Special C
Normal D
Normal E
Normal F