Question

问题是：ExampleIt从类It继承（并覆盖方法），这样当我在类Wrapped中重载运算符时（从{{1}调用某些方法） }，应由It覆盖。

想要的效果是，当我重载ExampleIt时，我应该能够调用operator*，这应该执行虚拟方法*name_of_Wrapped_class（来自dereference），应该被覆盖It。

ExampleIt

Answer 1

在真正回答之前，我不得不说你的班级等级和命名似乎有点可疑。您的解除引用运算符返回一个值而不是一个引用 - 这不是解引用在普通指针上的工作方式。

仍然，你要求它，所以你走了。实现operator*()重载的两个选项（每个都有其优缺点，我不会在这里讨论）：

运行时多态行为，使用指针：

class Wrapped {
protected:
    It* it;
public:
    std::pair<int, std::string> operator*() const {
        return it->dereference();
    };
};

使用Curiously Recurring Template Pattern (CRTP)编译时多态：
```
template <typename Base>
class Wrapped: Base {
public:
    std::pair<int, std::string> operator*() const {
        return Base::dereference();
    };
};
```
使用此选项，您甚至不需要It和ExampleIt相关联;任何使用dereference()方法的班级都可以。

Answer 2

以下是示例代码，我认为它显示了您想要的内容，

      #include <iostream>

      using namespace std;

      class It {
      public:
          virtual std::pair<int, std::string> dereference() const{
              std::cout << "it\n";
              return make_pair(3, "");
          }
      };

      class ExampleIt : public It {
      public:
        std::pair<int, std::string> dereference() const override{
              std::cout << "example it\n";
              return make_pair(2, "");
          }
      };

      class Wrapped {
          It * it;
      public:
          Wrapped() : it (new ExampleIt()) {}
           std::pair<int, std::string> operator*() const{
              std::cout << "Wrapped it\n";
              it->dereference();
              return make_pair(1, "");
           }
      };

      int main() {
          Wrapped p;
          auto x = *p;
          std::cout << x.first << std::endl;
      }

注意在构造期间使用类型ExampleIt分配了成员it。

多个但唯一的类继承

2 个答案: