Question

我已经问过a similar question here，但是我没有得到我想要的答案，因为我的问题制定得不好而且例子很糟糕。所以我再给它一个镜头，希望有更好的解释和更好的代码。

下面的代码已经被删除了不必要的细节，但它确实有效。问题是如果可能的话，我想使用Template Argument Deduction来简化模板化的函数调用。

我有一个创建命令的工厂。要创建命令，我使用类似的调用：

mCommandFactory.createCommand<
                        DoSomeStuff, 
                        ParameterType1, 
                        ParameterType2, 
                        ParameterType3, 
                        ParameterType4
                        >
                        (std:string("some description"), 
                         parameter1, 
                         parameter2, 
                         parameter3, 
                         parameter4);

正如您可能已经猜到的那样，parameter1类型是ParameterType1，依此类推......

现在，如果我们看一下命令的定义 - DoSomeStuff-本身：

class DoSomeStuff : public UndoableCommand< ParameterType1 , ParameterType2, ParameterType3 , ParameterType4 >
    {
    public:
      DoSomeStuff(... /* arguments which are needed for precessing the command and undoing it*/ );
      ~DoSomeStuff() throw();
      void executeImpl();
      void undoImpl();

    protected:
              ... /* members which are needed for precessing the command and undoing it*/ 
    };

如您所见，ParameterTypeN信息已经在DoSomeStuff声明中。

我想知道是否有可能通过更简单的方式替换上面的createCommand调用：

mCommandFactory.createCommand<DoSomeStuff>
                        (std:string("some description"), 
                         parameter1, 
                         parameter2, 
                         parameter3, 
                         parameter4);

这是CommandFactory代码：

    class CommandFactory
    {
    private:
          // some stuff used to initialize objects created by this factory 

    public:
        CommandFactory(...) : ... /* members initialization */

        {  
        }


        template <class CommandType, typename P1, typename P2, typename P3, typename P4> 
        void createCommand(juce::String& description,P1 p1, P2 p2, P3 p3, P4 p4)
        {
            Undoable* cmdPtr = new CommandType(p1, p2, p3, p4);
            ...
            // init cmdPtr

            (*cmdPtr)();            
        }

基本上，重点是移动CommandFactory中的复杂性，以保持“客户端代码”（对createCommand的调用）尽可能简单和简短。

有什么想法吗？

Answer 1

我不确定我是否正确理解了这个问题，但这应该可行。

template<typename ParameterType1 , typename ParameterType2, typename ParameterType3 , typename ParameterType4>
class UndoableCommand
{
public:
    UndoableCommand(ParameterType1 p1, ParameterType2 p2, ParameterType3 p3, ParameterType4 p4)
    {}
};

class DoSomeStuff : public UndoableCommand< int ,double, std::string , int>
{
public:
    DoSomeStuff(int p1, double p2, std::string p3, int p4)
        :UndoableCommand(p1,p2,p3,p4)
    {}
};

class CommandFactory
{
public:
    CommandFactory()
    {}

    template <class CommandType, typename P1, typename P2, typename P3, typename P4> 
    void createCommand( std::string& description,P1 p1, P2 p2, P3 p3, P4 p4)
    {
        UndoableCommand<P1,P2,P3,P4> * cmdPtr = new CommandType(p1, p2, p3, p4);

    }
 };

用作

CommandFactory fact;
fact.createCommand<DoSomeStuff>(std::string("description"),1,2.0,std::string("3"),4);

Answer 2

这里不需要特别的东西，你的方法mCommandFactory.createCommand<DoSomeStuff>(...);应该有效。编译器将自动从函数调用表达式中扣除给定参数的类型，并正确地实例化createCommand<>模板。

Answer 3

是的，您可以用更简单的东西替换它。您考虑过std::bind吗？

一旦你使用改变它来使用<function>，你的DoSomeStuff类将只是一个包含一对std::function的结构。

Answer 4

您可以将参数类型的typedef设置为Commandtype类，从而解析createCommand函数内的参数类型，而无需将它们明确地添加为模板参数。为了实现这一点，您可以将模板参数的typedef传递给该类中的UndoableCommand。

将命令模式，工厂模式和模板混合在一起......

4 个答案: