在 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();

而不是冗长的：

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

我希望这没有什么太不合理的地方。但是现在我希望能够对获取动物进行单元测试，因此理想情况下可以伪造 animal_getter 类（想象实际实现访问数据库或您在单元测试中不想要的东西，因此是假的） .因此，最好为“animal getter”类定义一个接口，然后创建一个实现该接口的假货。那么问题来了，这个界面可以写吗？这不会编译：

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

是否有可能挽救这个想法或者模板函数永远不能被声明为虚拟函数来定义包含它们的接口？

如果这个想法是行不通的，这是从什么时候开始出错的？是在编写模板函数时，它自己进行了转换？我是否应该在返回动物对象的东西上停下来，然后让调用者负责演员表？

Answer 1

模板、强制转换和类型标签在声明的用例中似乎没有任何用处（获取动物，然后立即利用其独特特征）。

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(); }

Answer 2

不允许使用虚拟模板函数，但是你的模板函数没有逻辑，所以在这种情况下我会使用：

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 3

使用类型转换破坏了此处使用模板的意义。 我不太清楚 getter 类的用途。它很清楚它用于保存某些预定类型的一些静态实例，但不清楚为什么它是一个处理所有类型的单个类。我看不到您获得太多收益，因为它没有太多代码，而且无论如何您都必须在调用中指定类型。 switch 语句是一个潜在的错误，如果你添加一个新的动物类型，它仍然可以编译，但是新的类型不会在 switch 中处理，你会得到一个运行时错误。

如果您不需要静态实例，只需构造正确的类型。

如果您确实需要它们，请考虑是否应由该类型管理它们（即，熊有获取熊实例的方法）。另一种选择（正如已经指出的那样）是公开你的 getter 持有的每种类型的静态实例。

如果您不想管理相关类中的静态实例，请考虑使用单独的 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
   }
};