C++ 用类模板扩展抽象基类

当我还希望有条件地编译纯虚函数的重写时，如何使用扩展模板扩展抽象基类

示例：给定基类

class AbstractBase {
public:
  virtual void func() = 0;
};

我想用这样的东西来扩展

enum class Opts{FOO, BAR};

template<Opts opt>
class Derived : public AbstractBase {
public:

  template<Opts op = opt>
  typename std::enable_if<op == Opts::FOO, void>::type func() {
    std::cout << "Foo" << "\n";
  }

  template<Opts op = opt>
  typename std::enable_if<op == Opts::BAR, void>::type func() {
    std::cout << "BAR" << "\n";
  }

};

enum类选择{FOO，BAR}；
模板
派生类：公共抽象库{
公众：
模板
typename std:：enable_if:：type func（）{
std:：cout只需为每个要特别处理的枚举值专门化类模板，例如

enum class Opts{foo, bar};

template<Opts opt>
class Derived;

template<>
class Derived<Opts::foo>
    : public AbstractBase
{
public:
    void func() override
    {
        std::cout << "Foo" << "\n";
    }
};

template<>
class Derived<Opts::bar>
    : public AbstractBase
{
public:
    void func() override
    {
        std::cout << "bar" << "\n";
    }
};

enum类选择{foo，bar}；
模板
类派生；
模板
类派生
：公共摘要库
{
公众：
void func（）重写
{
std:：cout只需为每个要特别处理的枚举值专门化类模板，例如

enum class Opts{foo, bar};

template<Opts opt>
class Derived;

template<>
class Derived<Opts::foo>
    : public AbstractBase
{
public:
    void func() override
    {
        std::cout << "Foo" << "\n";
    }
};

template<>
class Derived<Opts::bar>
    : public AbstractBase
{
public:
    void func() override
    {
        std::cout << "bar" << "\n";
    }
};

enum类选择{foo，bar}；
模板
类派生；
模板
类派生
：公共摘要库
{
公众：
void func（）重写
{
std:：cout您可以专门化函数：

#include <iostream>

class AbstractBase
{
    public:
    // You should have a virtual destructor:
    virtual ~AbstractBase() {}
    virtual void func() = 0;
};

enum class Opts
{
    FOO, BAR
};

template<Opts opt>
class Derived: public AbstractBase
{
    public:
    void func() override;
};

template<>
void Derived<Opts::FOO>::func()
{
    std::cout << "Foo" << "\n";
}

template<>
void Derived<Opts::BAR>::func()
{
    std::cout << "BAR" << "\n";
}

int main()
{
    Derived<Opts::FOO> foo;
    AbstractBase& bfoo = foo;
    bfoo.func();
    Derived<Opts::BAR> bar;
    AbstractBase& bbar = bar;
    bbar.func();
}

#包括
类抽象库
{
公众：
//您应该有一个虚拟析构函数：
虚拟~AbstractBase（）{}
虚void func（）=0；
};
枚举类选项
{
富，酒吧
};
模板
派生类：公共抽象库
{
公众：
void func（）覆盖；
};
模板
void派生：：func（）
{
std:：cout您可以专门化函数：

#include <iostream>

class AbstractBase
{
    public:
    // You should have a virtual destructor:
    virtual ~AbstractBase() {}
    virtual void func() = 0;
};

enum class Opts
{
    FOO, BAR
};

template<Opts opt>
class Derived: public AbstractBase
{
    public:
    void func() override;
};

template<>
void Derived<Opts::FOO>::func()
{
    std::cout << "Foo" << "\n";
}

template<>
void Derived<Opts::BAR>::func()
{
    std::cout << "BAR" << "\n";
}

int main()
{
    Derived<Opts::FOO> foo;
    AbstractBase& bfoo = foo;
    bfoo.func();
    Derived<Opts::BAR> bar;
    AbstractBase& bbar = bar;
    bbar.func();
}

#包括
类抽象库
{
公众：
//您应该有一个虚拟析构函数：
虚拟~AbstractBase（）{}
虚void func（）=0；
};
枚举类选项
{
富，酒吧
};
模板
派生类：公共抽象库
{
公众：
void func（）覆盖；
};
模板
void派生：：func（）
{
std:：cout函数模板不是虚拟的，所以它们不能覆盖任何内容。听起来你真的想要两个不同的派生类来看看著名的。函数模板不是虚拟的，所以它们不能覆盖任何内容。听起来你真的想要两个不同的派生类来看看著名的。我明白了。我有一小部分“helper”类。它们都很小，并且都只覆盖基类的一个虚拟成员函数。我想不保留它们，而是用模板来做一些事情。在我看来，保持原样可能没那么糟糕。我明白了。我有一个小的“helper”集合“类。它们都很小，并且都只覆盖基类的一个虚拟成员函数。我想不把它们全部保留下来，而是用模板做一些事情。在我看来，保持原样可能并不坏。