C++ 类是否可以包含其自身类型的成员

Java 垃圾收集器回收未使用的内存，而在 C++ 中，程序员需要处理它，可能使用 C++ 工具，例如 智能指针.

Java 垃圾收集器通过 Trace by Reachability、C++ 智能指针回收未使用的内存是基于作用域生命周期的.此外，C++ shared_ptr 基于 引用计数 有其优势，但会受到引用周期的影响，可能存在内存泄漏，应通过正确设计代码来避免这种情况.

Java Garbage Collector reclaims unused memory via Trace by Reachability, C++ smart pointers are based on scope lifetime. Additionally, C++ shared_ptr is based on reference counting which has its advantages, but is subject to reference cycles possible leak of memory, which should be avoided with proper design of your code.

坚持自己"的 C++ 版本可能看起来像以下任何一种(或它们的变体)，具体取决于具体需要:

The C++ version of "holding myself" may look like any of the below (or variations of them), depending on the exact need:

class A {
   A* a1 = nullptr;
   A* a2 = nullptr;

public: 
   A* getA1(){
      return a1;
   }

   A* getA2(){
     return a2;
   }

   void setA1(A* a1){
     this->a1 = a1;
   }

   void setA2(A* a2){
     this->a2 = a2;
   }
};

选项 2 - A 拥有 a1 和 a2 作为唯一资源

Option 2 - A owns a1 and a2 as unique resources

class A {
   std::unique_ptr<A> a1 = nullptr;
   std::unique_ptr<A> a2 = nullptr;

public: 
   A* getA1(){
      return a1.get();
   }

   A* getA2(){
     return a2.get();
   }

   void setA1(std::unique_ptr<A> a1){
     this->a1 = std::move(a1);
   }

   void setA2(std::unique_ptr<A> a2){
     this->a2 = std::move(a2);
   }
};

选项 3 - A 持有 a1 和 a2 作为共享资源^*

_{^* 需要确保避免循环所有权泄漏.}

Option 3 - A holds a1 and a2 as shared resources^*

_{^* need to make sure you avoid cyclic ownership leak.}

class A {
   std::shared_ptr<A> a1 = nullptr;
   std::shared_ptr<A> a2 = nullptr;

public: 
   auto getA1(){
      return a1;
   }

   auto getA2(){
     return a2;
   }

   void setA1(std::shared_ptr<A> a1){
     this->a1 = a1;
   }

   void setA2(std::shared_ptr<A> a2){
     this->a2 = a2;
   }
};

选项 4 - A 持有指向 a1 和 a2 的弱指针^*

_{^* std::weak_ptr 的选项在可能的循环依赖的情况下是相关的，a1 和 a2 在别处拥有并且可能不存在.}

Option 4 - A holds weak pointers to a1 and a2^*

_{^* the option of std::weak_ptr is relevant in case of possible cyclic dependency, a1 and a2 are owned elsewhere and might not be alive.}

class A {
   std::weak_ptr<A> a1 = nullptr;
   std::weak_ptr<A> a2 = nullptr;

public: 
   std::shared_ptr<A> getA1(){
      return a1.lock();
   }

   std::shared_ptr<A> getA2(){
     return a2.lock();
   }

   void setA1(std::shared_ptr<A> a1){
     this->a1 = a1;
   }

   void setA2(std::shared_ptr<A> a2){
     this->a2 = a2;
   }
};

_{选项 4 代码示例:http://coliru.stacked-crooked.com/a/92d6004280fdc147}

请注意，使用 A&(对 A 的引用)作为成员不是一种选择，因为在 C++ 中，引用变量比天主教婚礼更强，它们在变量的生命周期内没有以任何方式重新分配给另一个参考.并且必须在出生时将它们分配给有效的参考.

Note that using A& (reference to A) as a member, is not an option, as in C++ reference variables are stronger than Catholic wedding, they're for the lifetime of the variable without any way to reassign to another reference. And they must be assigned to a valid reference when born.

但是，如果 a1 和 a2 在对象出生时是已知的，在对象的生命周期内永不改变并保持活动状态，那么以下选项也是可能:

However, if a1 and a2 are known when the object is born, never change and stay alive for the duration of the object's lifetime, then the following option is also possible:

_{^* 这个选项主要是为了表明可以保存引用，但是在大多数情况下，指针选项(如选项 1)或 const 指针成员会更多适合.}

_{^* this option is mainly to show that it is possible to hold references, however in most cases a pointer option (like option 1), or a const pointer member, would be more suitable.}

class A {
   A& a1;
   A& a2;

public:
   A(A& a1, A& a2): a1(a1), a2(a2) {}

   // using ref to self as a placeholder
   // to allow the creation of "the first A"  
   A(): a1(*this), a2(*this) {}
  
   A& getA1(){
      return a1;
   }

   A& getA2(){
      return a2;
   }
};

int main() {
   A a1;
   A a2(a1, a1);
}

下面的最后一个也是最后一个选项，主要是提出继续使用选项 5 并允许更改 A 持有的引用的可能性.

The last and final option, below, is mainly to present the possibility of going forward with option 5 and allowing the change of the reference held by A.

此选项从 C++20 开始可用.但是，需要注意的是，为此目的使用指针很可能是更好的选择.

This option is possible since C++20. However, it is to be noted that using a pointer for this purpose would most probably be a better choice.

_{^*从C++20开始，注意这个选项主要是为了展示可能性，这里指针可能是更好的选择.}

_{^*since C++20, note that this option is mainly to show the possibility, pointers would probably be a better choice here.}

class A {
   // all same as in option 5
public:
   void set(A& a1, A& a2){
      A other(a1, a2);
      // placement new that changes internal ref
      // is valid since C++20
      new (this) A(other);
   }
};

_{选项 5b 的代码:http://coliru.stacked-crooked.com/a/43adef3bff619e99}

_{另请参阅:为什么我可以为引用分配一个新值，以及如何使引用引用其他内容?}

这篇关于C++ 类是否可以包含其自身类型的成员的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！