从子类嵌套类访问基类方法

Question

问题扩展了这个问题

情况如下。 我正在扩展内部类的虚拟方法：

class ClassOne {
public:
    class InnerClass {
    public:
            virtual void method1();
    protected:
        friend class ClassOne
    };    
protected:
    oftenUsedMethod();
private:
    friend class InnerClass;
};

void ClassOne::InnerClass::method1()
{
    #Do stuff with oftenUsedMethod();
}

class SubClassOne : public ClassOne {
    class DerivedInnerClass : InnerClass { 
        virtual void method1();
    };
};

void SubClassOne::DerivedInnerClass::method1()
{
    ##I need the access to the oftenUsedMethod???
}

这是一张试图澄清问题的图片：）

InnerClass在其方法中使用ofthenUsedMethod() ，并可以访问它。 为了能够扩展方法，我需要访问ofthenUsedMethod()在DerivedInnerClass 。 能做到吗？

Answer 1

有两个要解决的问题：

1. 默认情况下，内部类不与外部类的实例相关联，因此，您必须通过为其提供指向外部类的指针来使此依赖关系明确。 如果这样做，则需要注意内部类的实例不会超过它们所引用的对象。
2. 派生的内部类不是从外部类派生的，因此它无权访问其protected成员。 您可以做的是在InnerClass中添加一个protected函数，该函数将调用该函数。 该函数是InnerClass的成员，派生类可以调用它。 动态绑定将完成其余的工作。

这是C ++中的上述代码：

#include <iostream>

class ClassOne
{

protected:

  virtual void
  oftenUsedMethod()
  {
    std::clog << "ClassOne::oftenUsedMethod()" << std::endl;
  }

  class InnerClass
  {

  private:

    /** Pointer to an instance of the outer class. */
    ClassOne *const outer_;

  public:

    InnerClass(ClassOne *const outer) : outer_ {outer}
    {
    }

  protected:

    virtual void
    method1()
    {
      std::clog << "ClassOne::InnerClass::method1()" << std::endl;
      this->dispatch();
    }

    /**
     * Simply calls the protected member of the outer class.
     * Derived classes can therefore access it indirectly, too.
     *
     */
    void
    dispatch()
    {
      // Be aware: If *this->outer_ has already been destructed
      // (and there is no simple way for us to tell whether it has),
      // calling a member function on it will cause disaster.
      this->outer_->oftenUsedMethod();
    }
  };
};

class SubClassOne : public ClassOne
{

protected:

  virtual void
  oftenUsedMethod() override
  {
    std::clog << "SubClassOne::oftenUsedMethod()" << std::endl;
  }

  class DerivedInnerClass : public ClassOne::InnerClass
  {

    DerivedInnerClass(ClassOne *const outer) : InnerClass {outer}
    {
    }

  protected:

    virtual void
    method1() override
    {
      std::clog << "SubClassOne::DerivedInnerClass::method1()" << std::endl;
      this->dispatch();
    }
  };
};

override是C ++ 11的一项功能，您不需要它，但它可以使您的意图明确。