如何创建具有引用成员和指针向量的类？

Question

我对 C++ 相当陌生，并且正在从事一个个人项目。我想在 C++ 中创建一个 vector<Entity*> entitities，其中每个 Entity 对象都是唯一的。我在标题Entity.h 中有一个要创建的类。现在 Entity 有两个成员变量：

1. Rectangle rect - 一个 Rectangle 类型的对象，它有四个浮点变量作为成员变量（x1、y1、x2、y2），它们是矩形两个对角的坐标
2. vector<Component*> - 基类类型Component 的许多不同组件以及一些派生类。 Class Component 的代码如下所示：

/*************************** BASE CLASS **************************/
class Component
{
public:
    virtual ~Component() = default;
    virtual Component* Clone() = 0;
};

/*************************** DERIVED CLASS 1 **************************/
class BasicComponent: public Component
{
private:
    int B= 0;
public:
    BasicComponent* Clone() override {
        return new BasicComponent(B);
    }

    BasicComponent(const int& mB) :B(mB){}
    BasicComponent() :B(0) {}

};

/*************************** DERIVED CLASS 2 **************************/
class AdvancedComponent: public Component
{
private:
    float A = 0.f;
    int iA = 0;
public:
    AdvancedComponent* Clone() override {
        return new AdvancedComponent(A, iA);
    }

    AdvancedComponent(const float& mA, const int& miA) :A(mA),iA(miA) {}
    AdvancedComponent() :A(0.f),iA(0) {}

};

由于我希望实体向量中的每个Entity 都是唯一的，即拥有自己的矩形和组件，我应该如何创建类？

我的问题是，class Entity 应该是什么样子？我应该为这个类创建单独的 CopyConstructor、Assignment Constructor 和 Destructor 吗？另外，如果我想实现将一个实体复制到另一个实体（深度复制），是否有必要拥有全部 3 个（复制、赋值和析构函数）？

Answer 1

我的问题是，Entity 类应该是什么样的？我应该为这个类创建单独的 CopyConstructor、Assignment Constructor 和 Destructor 吗？另外，如果我想实现将一个实体复制到另一个实体（深度复制），是否有必要拥有全部 3 个（复制、赋值和析构函数）？

这个问题的答案并不真正取决于Entity 看起来像什么，而是取决于它打算具有什么语义。

您说每个Entity 都是“唯一的”，但C++ 中的每个对象（甚至每个int，即使它们碰巧具有相同的值）在技术上都是唯一的。那么你的真正意思是什么？

1. Entity 应该是可复制的吗？复制构造 Entity 意味着两个 Entity 对象具有相同的内容（字面意思是组件指针是浅拷贝的，逻辑上是深拷贝的）。

   如果不是，您可能不想编写（或可能明确地delete）复制构造函数和/或复制赋值运算符。

2. Entity 应该可以移动吗？可能是的，因为它不违反唯一性并且使它们更容易有效地使用。

   如果是这样，您应该确保它具有移动构造函数和移动赋值运算符（通过编写它或安排编译器生成有用的默认值）。

另外，如果我想实现将一个实体复制到另一个实体（深度复制）

这似乎违反了您的唯一性约束，但是是的，您需要一个复制构造函数和复制赋值运算符。

但是，最佳做法是避免将资源管理与程序逻辑交错。因此，与其编写所有这些，不如考虑让智能指针为您自动化它。请参阅this answer 中提到的零规则进行比较。

事实上，我们可以用很少的代码说明所有合理的语义：

template <typename ComponentPtr>
struct ZeroEntity
{
  Rectangle bound;
  std::vector<ComponentPtr> components;
};

using ShallowCopyZeroEntity = ZeroEntity<std::shared_ptr<Component>>;
using NoCopyOnlyMoveEntity = ZeroEntity<std::unique_ptr<Component>>;
using DeepCopyZeroEntity = ZeroEntity<my::clone_ptr<Component>>;

除了我们还需要写一个深拷贝clone_ptr，类似

namespace my {
template <typename T>
class clone_ptr
{
  std::unique_ptr<T> p_;

  std::unique_ptr<T> clone() const { return std::unique_ptr<T>{p_ ? p_->Clone() : nullptr}; }

public:

  using pointer = typename std::unique_ptr<T>::pointer;

  explicit clone_ptr(pointer p) : p_(p) {}

  // copy behaviour is where the cloning happens
  clone_ptr(clone_ptr const& other) : p_(other.clone()) {}
  clone_ptr& operator=(clone_ptr other)
  {
    other.swap(*this);
  }

  // move behaviour (and destructor) generated by unique_ptr
  clone_ptr(clone_ptr&& other) = default;
  clone_ptr& operator=(clone_ptr&&) = default;

  // now write all the same swap, release, reset, operator* etc. as std::unique_ptr
};
}

...如果这看起来很多，想象一下它会与您的 Entity 代码交错而不是像这样收集到一个地方会有多混乱。

Answer 2

主要目的只是启用实体的复制。这行得通吗？

#include "Components.h"
#include "Rectangle.h"
#include <vector>
using namespace std;
class Entity
{

public:
    Rectangle& Box;
    vector<Component*>& Components;

    //Default constructor call
    Entity(): Box(*new Rectangle), Components(*new vector<Component*>){}
 
    //Constructor call with parameters
    Entity(Rectangle& B, vector<Component*>& C) : Box(B), Components(C){}

    //Copy constructor that makes Entity copyable
    Entity(const Entity& E) : Box(*new Rectangle(E.Box)), Components(*new vector<Component*>(E.Components.size())) {
     
 
        for (unsigned int i = 0; i < E.Components.size(); i++) {
            Components[i] = E.Components[i]->Clone();
        }
    }

    //Assignment operator constructor
    Entity& operator=(const Entity& E){ 
        //Entity* pE = &E;
        if (this != &E)
        {
            delete& Box;
            delete& Components;
            Box = *new Rectangle(E.Box);
            Components = *new vector<Component*>(E.Components.size());
            for (unsigned int i = 0; i < E.Components.size(); i++) {
                Components[i] = E.Components[i]->Clone();
            }
        }
         return *this;

    }

};