c++ - 虚函数可以通过隐式类型转换实现吗？或者如何进行依赖于子类的类型转换？

Question

考虑两个类 class B 和 class C，每个类都有一个 int 类型的 private 成员，一个构造函数将 int 成员设置为零，以及一个 operator++() 成员函数，这样 B b;++b 将int成员加1，并且C c;++c 将成员增加 10。这就是多态性的经典示例。我们可以从一个公共(public)抽象基class A派生class B和class C，它有一个纯虚成员函数operator++() =0。当为 class B 和 class C 定义具体的 operator++() 函数时，我们可以使用 A& a=b;++a 将 a 的(int 成员)增加 1，并且 A& a=c;++a 将 a 增加 10。

现在情况稍微复杂一些。假设我们有

  class B{
    private:
      int n;
    public:
      B(int b=0) {n=b;}
      void output() {cout<<n<<endl;}
      operator int&() {return n;}
  };

  class C{
    private:
      int n;
    public:
      C(int c=0) {n=c;}
      void output() {cout<<n<<endl;}
      C& operator++() {n+=10; return *this;}
  };

使得 B b;++b 操作不是由成员函数 operator++() 完成的，而是通过 b 到 int& 的隐式类型转换> 引用其内部 int 成员，然后是 int 类型的 ++ 运算符。然后我发现多态性不再有效。

  class A{
    protected:
      int n;
    public:
      A(int a=0) {n=a;}
      void output() {cout<<n<<endl;}
      virtual A& operator++()=0;
  };

  class B:public A{
    public:
      operator int&() {return n;}
  };

  class C:public A{
    public:
      C& operator++() {n+=10; return *this;}
  };

以上代码只适用于A& a=c;++a 但不是 A& a=b;++一个。公共(public)基类A的纯虚operator++()=0被继承到类B并保持纯虚，所以 class B 变得抽象并且不能再定义任何对象，即使 ++b 实际上可以通过类型转换实现。

假设依赖于类的类型转换是我想要的一些特性，因为也许转换是昂贵的并且我不希望它发生在 class C 上，但不知何故我别无选择，只能为 B 类 做。我希望我的代码通过使用某种“多态性”变得聪明(即使直接的多态性在这里失败)。有人看到在 C++ 中进行这种依赖于子类的类型转换的方法吗？我的意思是，当我执行 ++a 时，它会被转换为 int 然后 ++ 如果 a 是一个 B，但如果 a 是一个 C，则由成员函数直接 ++ >?

Answer 1

您可以通过 CRTP 执行此操作

例子:

template <class T>
class Base
{
private:
    int n;
public:
    T& operator++() {n+=10; return *this;}
    ...
};

class C : public Base<C>
{
    ...
};

注意:这只是为了代码复用，没有共同的基类(因为模板各不相同)

如果你需要一个通用的基类，你可以通过 3 个类来实现

class Base
{
protected:
    int n;
};


template <class T>
class BaseOperator : public Base
{

public:
    T& operator++() {n+=10; return *this;}
};

class C : public BaseOperator<C>
{
    ....
};