擁有可變數量模板參數的最佳方式是什麼？

Question

請考慮這個 - 可能須寫不好例如：

class Command; 

class Command : public boost::enable_shared_from_this<Command> 
{ 
    public : 
    void execute() 
    { 
    executeImpl(); 
       // then do some stuff which is common to all commands ... 
    } 

    // Much more stuff ... 
    private: 
     virtual void executeImpl()=0; 
     // Much more stuff too ... 
}; 

和：

class CmdAdd : public Command 
{ 
public: 
    CmdAdd(int howMuchToAdd); 
    void executeImpl(); 


    int _amountToAdd; 
}; 

// implementation isn't really important here .... 

有了這個，我可以使用此語法只需添加一個回調：

 boost::shared_ptr<Command> cmdAdd(CmdAdd(someValue)); 
    cmdAdd->execute(); 

它的工作原理完美無缺。我的「Command」類對所有命令都做了很多事情，比如實現撤銷，重做，進度報告等，但爲了可讀性，我從代碼中刪除了它。

現在我的問題很簡單： 有沒有辦法改寫命令類，這樣我可以取代這個呼叫：通過類似

boost::shared_ptr<Command> cmdAdd(CmdAdd(someValue)); 
cmdAdd->execute(); 

：

CmdAdd(someValue); // preferably 
or CmdAdd->execute(someValue) 

我已經一直在想這很多，但我有一個概念問題： 我想模板我的命令類如

template <typename R,typename T1, typename T2, ..., typename Tn> class Command 
{ 
    R1 execute(T1 p1, ...,Tn pn) 
    { 
     return executeImpl(T1 p1, ...,Tn pn); 
     // then do some stuff which is common to all commands ... 
    } 
} 

但很明顯，這裏有一個問題： 語法template <typename R,typename T1, typename T2, ..., typename Tn>是不合法的C++，AFAIK。

我必須寫命令的N個版本，如：

template <typename R> class Command 
template <typename R,typename T1> class Command 
template <typename R,typename T1, typename T2> class Command 
... 

等等？ （甚至不知道這是否會工作確實）

或者是有另一種更優雅的方式來做到這一點？ 是語法，提到here有什麼用處？ （函數f;）

我一直在看Loki的類型列表，他們似乎做的工作。但我在Boost找不到任何東西。我在網上讀到boost :: mpl是用來實現類型列表的，但是我對MPL文檔有點困惑？

對此有何見解？ Regads， D.

Answer 1

有趣的問題:)

首先，有你忽略了一個問題：你需要一個公共基類的所有Command這個類不能作爲模板，如果你打算使用它們的堆棧（有關撤銷重做）。

因此你被卡住：

class Command 
{ 
public: 
    void execute(); 
private: 
    virtual void executeImpl() = 0; 
}; 

我能理解你的慾望與參數執行的功能，但不要忘了，反正你將需要保存這些參數的撤銷/重做操作。通過構造函數讓它們更簡單。

不過，你仍然可以使用模板方法來實際調用命令：

template <class Command> 
void execute() { Command cmd; cmd.execute(); } 

template <class Command, class T0> 
void execute(T0& arg0) { Command cmd(arg0); cmd.execute(); } 

/// ... 

int main(int argc, char* argv[]) 
{ 
    execute<MyLittleCommand>("path", 3); 
} 

這是接近你想要的語法。請注意，我有意忘記了這裏的堆棧，在我看來，您需要將它傳遞給execute註冊方法（一旦完成）。

不，我也可能改變Command設計更接近一個策略模式：

struct CommandImpl 
{ 
    virtual ~CommandImpl(); 
    virtual void executeImpl() = 0; 
}; 

class Command 
{ 
public: 
    template <class C> 
    static Command Make() { return Command(new C()); } 

    template <class C, class T0> 
    static Command Make(T0& arg0) { return Command(new C(arg0)); } 

    /// .... 

    void execute(CommandStack& stack) 
    { 
    mImpl->executeImpl(); 
    stack.Push(*this); 
    } 

private: 
    Command(CommandImpl* c): mImpl(c) {} 
    boost::shared_ptr<CommandImpl> mImpl; 
}; 

它的非虛擬接口和指針，以實現成語的典型組合。

Answer 2

AFAIK你不能用當前的C++標準來做到這一點。一些boost代碼使用宏和其他預處理來模擬可變模板（我認爲boost :: pool或boost :: object_pool使用類似的東西）。

然而，variadic templates將在下面的標準C++ 0x中來，並根據該頁面已經GCC提供實現開始V4.3：http://gcc.gnu.org/projects/cxx0x.html

如果你使用它，您可以通過啓用激活C++ 0x。

Answer 3

Klaim指出，可變模板是解決這個問題的最終方法。然而，有一種方法可以讓一個可變數量的使用類型列表模板參數：

template <class H, class T> 
struct typelist 
{ 
    typedef H head; 
    typedef T tail; 
}; 

這允許你寫typelist<typelist<int, float>, double>，例如。然而，這是讀取和寫入的一個真正的痛苦，並且是boost :: function使用暴力方法（對於每個模板參數數量的單獨類）的主要原因：boost :: function0，boost :: function1 ，boost :: function2等等的後端實現。它比通過模板元編程遞歸遍歷類型列表要容易得多。

至於一個普遍的答案，我把它發佈在另一個線程中，你最初有這個問題以及另一個線程。

Answer 4

乍一看，可變模板看起來像是一個完美的解決方案。不幸的是，他們不虛函數發揮出色：

template <typename... Args> 
void execute(Args&&... args) 
{ 
    executeImpl(std::forward<Args>(args)...); 
} 

這需要executeImpl是一個虛擬成員函數模板，但在C++中沒有這樣的事！