如何使具有包含唯一指针的成员变量的类可复制分配？

Question

I have a class (PlayerCharacter) that contains a map which in turn contains unique pointers. I have another class (Party) which should contain multiple instances of this first class. When I try to implement a constructor for Party that takes an instance of PlayerCharacter and copies it into the first element of a vector I get multiple errors (using g++) which are too long to put into this question.

I believe the error arises because BaseCharacter, and therefore PlayerCharacter, is not copy-assignable due to the unique pointers. How can I implement a complete copy constructor for this class?

MCVE below

#include <map>
#include <utility>
#include <memory>
#include <vector>

enum class EQUIPMENT_SLOT {
    HEAD
};
class WeaponItem {};
class ClothingItem{};
class BaseCharacter {
    private:
        std::map<EQUIPMENT_SLOT, std::pair<std::unique_ptr<WeaponItem>, std::unique_ptr<ClothingItem>>> _equipment;
};
class PlayerCharacter : public BaseCharacter {};
class Party {
    private:
        std::vector<PlayerCharacter> _party_members;
    public:
        // Addition of this constructor causes errors to appear
        Party(PlayerCharacter player){
            this->_party_members.clear();
            this->_party_members.push_back(player); // This line is the problem - commenting it out compiles fine
        };
};
int main(){
    return 0;
}

Answer 1

If you're holding items in a unique_ptr, it normally implies that you're not looking to copy them. If you want to copy them you'll have to provide the mechanism to do so:

struct my_thing {
};

using my_thing_ptr = std::unique_ptr<my_thing>;

struct my_container
{
  my_container() {}

  // the presence of _thing will implicitly delete copy constructor 
  // and copy operator so we need to provide them. 
  // Since we're defining copy operators, these will disable 
  // the automatic move operators so we need to define them too!

  my_container(const my_container& rhs)
  : _thing { rhs._thing ? new thing { *(rhs._thing) } : nullptr }
  {}

  my_container(my_container&& rhs) = default;

  my_container& operator=(const my_container&& rhs) {
    auto tmp = rhs;
    swap(tmp, *this);
    return *this;
  }

  my_container& operator=(my_container&& rhs) = default;

  // and an implementation of swap for good measure
  void swap(my_container& other) noexcept {
    using std::swap;
    swap(_thing, other._thing);
  }


  my_thing_ptr _thing;

};