在C++接口中聲明模板函數？

Question

對於一個示範的緣故想象，我有一些動物類，每一類由「動物」類派生的，每個「知道」，他們是什麼類型的，並且每個具有某種獨特的能力：

enum class animal_type { antelope, bear, cat }; 

class animal 
{ 
}; 

class antelope : public animal 
{ 
public: 
    static const animal_type type = animal_type::antelope; 
    void run() { std::cout << "antelope runs\n"; }; 
}; 

class bear : public animal 
{ 
public: 
    static const animal_type type = animal_type::bear; 
    void roar() { std::cout << "bear roars\n"; }; 
}; 

class cat : public animal 
{ 
public: 
    static const animal_type type = animal_type::cat; 
    void meow() { std::cout << "cat meows\n"; }; 
}; 

現在，我想根據自己的類型，能夠檢索動物：

class animal_getter 
{ 
public: 
    animal& get(animal_type t) 
    { 
     static antelope s_antelope; 
     static bear s_bear; 
     static cat s_cat; 

     switch (t) 
     { 
      case animal_type::antelope: 
       return s_antelope; 

      case animal_type::bear: 
       return s_bear; 

      case animal_type::cat: 
       return s_cat; 
     } 
    } 
}; 

最後，這將是很好得到的實際類型動物的背部，使調用語法更好：

template<typename T> 
T& get() 
{ 
    return static_cast<T&>(get(T::type)); 
} 

現在

我可以寫這樣的事：

animal_getter ag; 
ag.get<antelope>().run(); 

而非wordier：

animal_getter ag; 
static_cast<antelope&>(ag.get(animal_type::antelope)).run(); 

我希望沒有什麼太不合理有關。但是現在我想能夠單元測試獲取動物，所以理想情況下可以僞造animal_getter類（假設實際的實現訪問數據庫或者單元測試中不需要的東西，因此是假的） 。所以最好定義一個「動物吸氣」類的接口，然後創建一個實現該接口的假。這裏的問題，可以寫這個接口？這是不會編譯：

struct IAnimalGetter 
{ 
    virtual template<typename T> T& get() = 0; 
}; 

是否有可能挽救這個想法或者模板函數永遠不會被宣佈爲虛擬定義，包括用戶的界面的目的是什麼？

如果這個想法不是首發，那麼在什麼時候開始出問題了？當模板函數被寫入了它自己的模型嗎？我是否應該停止返回一個動物對象，然後讓調用者對演員負責？

Answer 1

虛擬模板功能是不允許的，但你的模板函數沒有邏輯，所以在這種情況下，我會用：

struct IAnimalGetter 
{ 
    virtual animal& get(animal_type t) = 0; 

    template<typename T> 
    T& get() 
    { 
     return static_cast<T&>(get(T::type)); 
    } 
}; 

和：

class animal_getter : public IAnimalGetter 
{ 
public: 
    animal& get(animal_type t) 
    { 
     // implementation 
    } 
}; 

class mock_animal_getter : public IAnimalGetter 
{ 
public: 
    animal& get(animal_type t) 
    { 
     // mock implementation 
    } 
}; 

Answer 2

使用鑄造那種失敗的這裏使用模板的要點。 對於我來說，它並不是很清楚吸氣劑類的用途。它清楚地說明了它保存一些預定義類型的靜態實例，但不清楚爲什麼它的一個類處理所有類型。我看不到你獲得太多，因爲它沒有太多的代碼，你必須在通話中指定類型。 switch語句是一個潛在的錯誤，如果添加一個新的動物類型，它仍然會編譯，但新類型不會在交換機中處理，並且會出現運行時錯誤。

如果您不需要靜態實例，只需構建正確的類型即可。

如果你確實需要它們，那麼考慮它們是否應該由該類型管理（即熊有一個方法來獲得熊實例）。另一個選項（正如已經指出的那樣）是暴露你的getter持有的每種類型的靜態實例。

如果你不想管理靜態實例在相關的類時，請考慮單獨干將：

template<typename T> 
struct IGetter 
{ 
    virtual T Get() =0; 
}; 

template<typename T> 
struct RealGetter : public IGetter<T> 
{ 
    static T item; 
    virtual T Get() 
    { 
     return item; 
    } 
}; 

template<typename T> 
struct MockGetter : public IGetter<T> 
{ 

    virtual T Get() 
    { 
    // some mock implementation 
    } 
}; 

Answer 3

模板和管型和類型的變量似乎並沒有什麼用處的聲明用例（獲取動物，然後立即利用其獨特的特徵）。

antelope& get_antelope(); 
bear& get_bear(); 
cat& get_cat(); 

這就是所有需要的。

get_antelope().run(); 
get_cat().meow(); 

這些函數可以是獨立的或成員的，如果需要，可以是虛擬的。每個返回類型需要一個函數。這與每個返回類型的switch語句中的一種情況沒有什麼不同，並且在某些方面優於它。

如果出於某些尚未明確的原因需要函數模板，則可以基於普通函數定義一個函數模板。

template <class A> 
A& get_animal(); 

template<> antelope& get_animal<antelope>() { return get_antelope(); } 
template<> bear& get_animal<bear>() { return get_bear(); } 
template<> cat& get_animal<cat>() { return get_cat(); }