Question

我有一个A类，需要指向AA的指针才能工作，构造函数需要它。我有一个继承自A的B级，向A提供一个继承自AA的BB级。示例：

class A
{
  public:
    class AA
    {
      virtual void do_something() const;
    };
  protected:
    const AA* aa;
  public:
    A(const A::AA* aa_) : aa(aa_) {}
    void use() const { this->aa->do_something(); }
};

class B : public A
{
  public:
    class BB : public A::AA
    {
      virtual void do_something() const;
    };
  public:
    B() : A(new BB()) {}
};

现在，我想将B实例的地址提供给BB实例。这样的事情：

class B : public A
{
  public:
    class BB : public A::AA
    {
      BB(B* b);
      virtual void do_something() const;
    };
  public:
    B() : A(new BB(this)) {}
    // It doesn't work beacause the instance is not yet created
};

或类似的东西：

class B : public A
{
  public:
    class BB : public A::AA
    {
      virtual void do_something() const;
      void setPointer(B* b);
    };
  public:
    B() : A(new BB()) { static_cast<BB*>(this->aa)->setPointer(this); }
    // It doesn't work because this->aa is const
};

我该怎么做？是否有解决此类问题的设计模式？

Answer 1

将AA::do_something公开或受保护且BB的构造函数设为公开，makes your code compilable。

重构一点，你也可以得到一个不错的版本：

class A {
public:
    struct AA {
        virtual void do_something() const;
    };

    A(A::AA const* aa_) : aa(aa_) {}
    void use() const { this->aa->do_something(); }
protected:
    AA const* aa;
};

struct B : public A {
    struct BB : public A::AA {
        BB(B* b) {}
        virtual void do_something() const override;
    };
    B() : A(new BB(this)) {}
};

Live demo

Answer 2

如果你只想要BB：BB来存储指针，那么

    B() : A(new BB(this)) {}

应该可以正常工作。

如果你想要使用指针，那么最好的办法是将指针存储在构造函数中，并在第二个函数中使用它：

   B() : A(new BB(this)) { static_cast<const BB*>(this->aa)->UseStoredThis();

假设您可以将UseStoredThis标记为const。如果没有，那么你将需要：

   B() : A(new BB(this)) 
   { 
       const auto pcBB = static_cast<const BB*>(this->aa);
       const auto pBB = const_cast<BB*>(pcBB);
       pBB->UseStoredThis();
   }

具有指向自身的指针的类层次结构

2 个答案: