在 C++ 中可以有一个虚拟类型吗？

Question

我有一个类MyClass（带有几个虚函数），它对一个名为MyType 的对象执行操作。

MyClassImpl类继承MyClass并实现了虚函数，但是我需要给MyType添加额外的成员，但是我不想修改类MyType（而是我想保留它通用）。

现在，如果我创建一个MyTypeImpl 并继承MyType，我可以添加成员。但是，如何使MyClassImpl（继承自MyClass）中的非虚函数使用新的MyTypeImpl？

我能想到的唯一方法是让MyClass 使用MyTypeImpl，但我想避免在泛型类中使用实现，因为我可能会使用各种不同的实现。

下面是一个简单的类可能是什么样子的例子。当然，代码不会编译，因为MyTypeImpl而不是MyType中添加的方法和成员。

class MyType {
  public:
    void increment() {
      data_++;
    }
  protected:
    int data_ = 0;
};

class MyClass {
  public:   
    void alg() {
      sub_routine_1();
      sub_routine_2();
      modify_mytype();
    };

  protected:
    MyType mytype_;

    virtual void sub_routine_1() = 0;
    virtual void sub_routine_2() = 0;

    void modify_mytype() {
      mytype_.increment();
    };
};

class MyTypeImpl : public MyType {
  public:
    void decrement() {
      data_--;
      is_decremented = true;
    };

  protected:
    bool is_decremented = false;;
};

class MyClassImpl : public MyClass{
  public:
    void print() {
      mytype_.print();
    };
  protected:
    virtual void sub_routine_1() {
      //do algorithm things here
      mytype_.increment();
      mytype_.increment();
    };
    virtual void sub_routine_2() {
      //do more algorithm things here
      mytype_.decrement();
      mytype_.decrement();
    };
};

Answer 1

看到您的示例后，我现在看到您只想扩展该类的功能而不修改原始类。如果您需要添加其他功能，但您不想更改存储在 MyClass 中的类型，那么我没有任何方法可以做到这一点，除非至少修改 MyType 以包含虚拟功能您要调用的函数。

您还需要使 MyClass 获取指向 MyType 的指针，以便您可以使用多态性并使调用解析为正确的实现：

动态多态性解决方案：

#include <iostream>

class MyType {
  public:
    virtual void increment() {
      data_++;
    }

    // To be implemented by implementation class
    virtual void print() = 0;

    // To be implemented by implementation class
    virtual void decrement() = 0;

  protected:
    int data_ = 0;
};

class MyTypeImpl : public MyType
{
public:
    void print() {
        std::cout << 42 << std::endl;
    }

    void decrement() {
        data_--;
        is_decremented = true;
    };

protected:
    bool is_decremented = false;;
};

class MyClass {
  public:
    MyClass(MyType* mytype)
        : mytype_(mytype)
    {}

    void alg() {
      sub_routine_1();
      sub_routine_2();
      modify_mytype();
    };

  protected:
    MyType* mytype_;

    virtual void sub_routine_1() = 0;
    virtual void sub_routine_2() = 0;

    void modify_mytype() {
      mytype_->increment();
    };
};

class MyClassImpl : public MyClass{
  public:
    MyClassImpl(MyType* mytype)
        : MyClass(mytype)
    {}

    void print() {
      mytype_->print();
    };
  protected:
    virtual void sub_routine_1() {
      //do algorithm things here
      mytype_->increment();
      mytype_->increment();
    };
    virtual void sub_routine_2() {
      //do more algorithm things here
      mytype_->decrement();
      mytype_->decrement();
    };
};

int main()
{
    MyType* mytype = new MyTypeImpl();
    MyClass* myclass = new MyClassImpl(mytype);

    // Prints "42"
    myclass->print();

    // Do other stuff with "myclass"

    delete myclass;
    delete mytype;
}

请注意，我在此示例中仅使用原始指针以提高清晰度。强烈建议您不要使用new 和delete，而是使用智能指针来管理指针的生命周期。

静态多态性解：

并不是说这个解决方案的设计实际上更好，但我认为这更接近你真正想要的，因为它不需要直接修改MyType 类。此外，MyClass 所需的唯一修改是使其成为模板类：

#include <iostream>

class MyType {
  public:
    virtual void increment() {
      data_++;
    }

  protected:
    int data_ = 0;
};

class MyTypeImpl : public MyType
{
public:
    void print() {
        std::cout << data_ << std::endl;
    }

    void decrement() {
        data_--;
        is_decremented = true;
    };

protected:
    bool is_decremented = false;
};

template <typename T>
class MyClass {
  public:

    void alg() {
      sub_routine_1();
      sub_routine_2();
      modify_mytype();
    };

  protected:
    T mytype_;

    virtual void sub_routine_1() = 0;
    virtual void sub_routine_2() = 0;

    void modify_mytype() {
      mytype_.increment();
    };
};

template <typename T>
class MyClassImpl : public MyClass<T> {
  public:
    void print() {
      this->mytype_.print();
    };

  protected:
    virtual void sub_routine_1() {
      //do algorithm things here
        this->mytype_.increment();
        this->mytype_.increment();
    };
    virtual void sub_routine_2() {
      //do more algorithm things here
        this->mytype_.decrement();
        this->mytype_.decrement();
    };
};

int main()
{
    // Use the template to get the correct implementation
    MyClassImpl<MyTypeImpl> myclass;

    myclass.alg();
    myclass.print();

    // Do other stuff with my class
}