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来实现此目的的最佳方法是什么，还是有更好的方法？只要A本身的实例持续，我希望引用my_p能够持续。

顺便说一句，我是否必须重新声明变量SSP＆amp; A类中的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。

参考文献：我是否会超出范围？

1 个答案: