How do I create a class with reference member and vector of pointers?

My question here is, what should the class Entity look like ? Should I create separate CopyConstructor, Assignment Constructor and Destructor for this class ? Also if I want to implement copying one Entity into another (deep copying), is it necessary to have all 3 (Copy, Assignment and Destructor) ?

The answer to this doesn't really depend on what the Entity looks like, but on what semantics it is intended to have.

You say every Entity is "unique", but every object in C++ (even every int, even when they happen to have the same value) is technically unique. So what do you really mean?

1. Should an Entity be copyable? Copy-constructing an Entity would mean two Entity objects have the same contents (literally if the component pointers are shallow-copied, and logically if they're deep-copied).

   If not, you probably don't want to write a (or may explicitly delete the) copy constructor and/or copy-assignment operator.

2. Should an Entity be moveable? Probably yes, since it doesn't violate uniqueness and makes them easier to use efficiently.

   If so, you should make sure it has a move constructor and move-assignment operator (either by writing it or arranging for the compiler to generate useful defaults).

Also if I want to implement copying one Entity into another (deep copying)

That seems to violate your uniqueness constraint, but yes, you'd want a copy constructor and copy-assignment operator for this.

However, best practice is to avoid interleaving resource management with your program logic. So, instead of writing all these, consider having a smart pointer automate it for you. See for comparison the Rule of Zero mentioned in this answer.

In fact, we can illustrate all the reasonable semantics with very little code:

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>>;

except for the fact that we still need to write a deep-copying clone_ptr, something like

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
};
}

... and if that looks like a lot, imagine how messy it would have been interleaved with your Entity code instead of collected into one place like this.