c++ - 引用文献 : am I going to go out of scope?

Question

我是 C++ 的新手，更习惯于 Java 和 C#，所以我需要你的帮助。

我有这种情况:我有一个抽象类 SS 表示一种构造特定方案的方法。该方案使用内部类 SSP，这是另一个抽象类。 原因是我可以对 SS 和 SSP 有不同的实现，但我希望它尽可能通用。

现在，SS 的一种可能实现是 A，SSP 的相应实现是 AP。所以，我有类似的东西

class SSP {
  // abstract class
}

class SS {
  // abstract class
  SSP & my_p; // since this is an abstract member, I need a reference or a pointer here
  ...

  SS(SSP & p):
    my_p(p)
  {}
  ...

}

class AP : public SSP {
  int my_a;
  int my_b;

  AP(int a, int b):
    my_a = a, my_b = b
  {...}
}

class A : public SS {
  ...
  A(int a, int b):
    SS( AP(a,b) )
  {}
}

现在，这段代码让我感到困扰的是我将获得超出范围的引用的感觉。当我在 A 的构造函数中隐式创建 AP 时，该临时对象是否会在构造函数完成后立即销毁？如果是这样，那么 A 中的 my_p 的值是否未定义？

最好的方法是什么，在构造函数中使用指针和特定的 new，还是有更好的方法？我希望引用 my_p 的持续时间与 A 实例本身的持续时间一样长。

顺便说一下，我是否必须在类 A 中重新声明变量 SSP 和 my_p，这次作为 AP？

谢谢大家。

Answer 1

如果您使用原始引用/指针，您的类将无法控制传入值的生命周期。另请注意，通过将引用用作类成员，您是在强制类型的对象“SS”一旦构建，就永远不会为“m_p”设置不同的值。我建议使用指针而不是引用。

现在，绝对保证成员生命周期的唯一方法是在构造函数中提供值时获取值的所有权。您可以使用原始指针(和简单的书面合约)来执行此操作，或者更优选地，使用诸如智能指针之类的语言功能来执行此合约。无论哪种方式，分配都需要从生命周期超过包含对象的生命周期的竞技场(堆或类似的东西，但不是堆栈)发生。

使用 shared_ptr 重写的代码:

#include <iostream>
#include <memory>

using namespace std;
    class SSP {
      // abstract class
    };

    class SS {
      // abstract class
      std::shared_ptr<SSP> my_p; // since this is an abstract member, I need a reference or a pointer here
      // ...
      public:
      SS(std::shared_ptr<SSP> p):
        my_p(p)
      {}
      // ...

    };

    class AP : public SSP {
      int my_a;
      int my_b;
      public:
      AP(int a, int b):
        my_a(a), my_b(b)
      {//...
      }
    };

    class A : public SS {
      // ...
      A(int a, int b):
        SS(std::make_shared<AP>(a,b))
      {}
    };

int main() {
    // your code goes here
    return 0;
}

如果您的对象是指针的唯一所有者，您应该考虑使用 unique_ptr。