Question

我正在编写一个带有管道和舞台架构的Synthesizer。我目前以这种方式创建我的舞台：

的main.cpp

Stage *s1 = pipeLine.AddStage(StageRegistry::StageId::SIN_OSCILLATOR);
Stage *s2 = pipeLine.AddStage(StageRegistry::StageId::WAVE16BIT_WRITER);
Stage *s3 = pipeLine.AddStage(StageRegistry::StageId::LINEAR_ENVELOPE);
Stage *s4 = pipeLine.AddStage(StageRegistry::StageId::MULTIPLIER);

我在名为StageRegistry的类中使用Factory方法。很明显，每个专门的阶段类都有可变参数，这对我来说不会有用。我目前正在编写所有构造函数参数：

StageRegistry.cpp

Stage* StageRegistry::CreateStage(const StageId stageId)
{
    Stage *s = nullptr;

    switch (stageId)
    {
        case StageId::SIN_OSCILLATOR:
        {
            return new SinOscillator(48);
        }
        break;

        case StageId::WAVE16BIT_WRITER:
        {
            return new WaveFileWriter("out1.wav", 1);
        }
        break;

        case StageId::LINEAR_ENVELOPE:
        {
             return new LinearEnvelope(0.2f, 0.3f, 0.8f);
        }

        case StageId::MULTIPLIER:
        {
            return new Multiplier();
        }
        break;
    }

    return s;
}

我有什么选择？重要的是我返回一个Generic Stage *类，以避免转换为管道连接的特定类。

的main.cpp

SharedBuffer *sb0 = pipeLine.CreatePipe();
SharedBuffer *sb1 = pipeLine.CreatePipe();
SharedBuffer *sb2 = pipeLine.CreatePipe();
s1->SetOutputPipe(0, sb0);
s3->SetOutputPipe(0, sb1);
s4->SetInputPipe(0, sb0);
s4->SetInputPipe(1, sb1);
s4->SetOutputPipe(0, sb2);
s2->SetInputPipe(0, sb2);

我的体系结构真的很早，所以我想正确地解决这个问题，一些文献和一般建议是我想要的。我不确定自己想要什么。

Answer 1

另一种可能性是让课程在StageRegistry注册。 StageRegistry看起来像这样：

typedef Stage* (*CreateStage)();
typedef map<StageId, CreateStage> CreateStageMap;
CreateStageMap CreateStageFunctions;

StageRegistry::RegisterStage(const StageId stageId, CreateStage CreateStageFunction)
{
    CreateStageFunctions[stageId]=CreateStageFunction;
}

Stage* StageRegistry::CreateStage(const StageId stageId)
{
    if (CreateStageFunctions.find(stageId) == CreateStageFunctions.end() )
        return nullptr;

    CreateStage CreateStageFunc =CreateStageFunctions[stageId];
    Stage *s = *CreateStageFunc();
    return s;
}

对于要注册自身的类，定义一个自己创建的函数;

Stage* CreateLinearEnvelope()
{
     return new LinearEnvelope(0.2f, 0.3f, 0.8f);
}

在程序启动期间在注册表中注册;

RegisterStage(tageId::LINEAR_ENVELOPE, &CreateLinearEnvelope);

工厂职能也可能是集体成员;

typedef Stage* (Stage::*CreateStage)();

如果初始化是单线程的，或者你负责同步，那么

RegisterStage和CreateStageFunctions可能是静态的。

工厂的替代品（类设计）

1 个答案: