How to use unique_ptr as children in a tree - c++

Question

I'm trying to make a tree with unique_ptr as children. This is the class for the moment :
class Part
{
public:
vector<Part>& getChildren() const {
return *m_children;
}
void attachChild(const unique_ptr<Part>& child) {
m_children.push_back(std::move(child));
}
vector<Part>& getAtoms() const {
vector<Part> atoms;
for (const auto& child : m_children) {
if (child->hasChildren()) {
vector<Part> childChildren = child->getAtoms();
atoms.insert(atoms.end(), childChildren.begin(), childChildren.end());
} else {
atoms.push_back(child);
}
}
return atoms;
}
vector<Part>& getAbsoluteAtoms() const {
vector<Part> atoms;
for (auto child : m_children) { // Not const because I modify the child
if (child->hasChildren()) {
vector<Part> childChildren = child->getAbsoluteAtoms();
atoms.insert(atoms.end(), childChildren.begin(), childChildren.end());
} else {
child.setPosition(child->getPosition() + m_position);
atoms.push_back(child);
}
}
return atoms;
}
private:
vector<unique_ptr<Part>> m_children;
};
I have a lot of errors, because of the pointers, like this one :
D:\Programmes\Qt\Tools\mingw530_32\i686-w64-mingw32\include\c++\bits\stl_construct.h:75: error: use of deleted function 'std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = Part; _Dp = std::default_delete<Part>]'
{ ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
^
Without them, everything works well but as a child can get really huge, I need them. Can you tell me why my code isn't correct?

Answer 1

With all due respect, I think you need to work on the basics of C++. For me it has been impossible to deduce what you want to achieve with this code. Maybe I could help you pointing out some mistakes, as I believe that should be your first step.
Bad use of std::move
void attachChild(const unique_ptr<Part>& child) {
m_children.push_back(std::move(child));
}
Why would you want to move a const&? And if it weren't a constant reference, do you think it would be worth moving it? And why is this a unique_ptr? m_children holds elements of type unique_ptr, and you want to fill that vector with the addChild method? Can we copy unique_ptr? They wouldn't be unique anymore. All of this is very strange. Impossible to understand what your intentions are.
Return type
vector<Part>& getAtoms() const { vector<Part> atoms; /* fill atoms */ return atoms; }
Are you sure you want to return a reference to a variable which gets destructed at the end of the getAtoms() function? The returntype should be
vector<Part>
Same here:
vector<Part>& getAbsoluteAtoms() const { ... }
vector<unique_ptr<Part>> m_children needed?
vector<unique_ptr<Part>> m_children;
I really wonder why you need to store a vector of unique_ptr in a class attribute. I'm sure you'll have your reasons. But before continuing, I'd revisit the basics of C++ (copy, reference, pointer, moving semantics, ...).

Answer 2

The error you mentioned tells you that you use the deleted copy constructor of unique_ptr. The reason why it is deleted, is that as the name implies there must always be just one unique_ptr that owns an allocated object.
One use of this copy constructor is in the default generated copy constructor of your Part class, which is used for example whenever you insert a Part into a vector<Part>. Another use is in the for (auto child : m_children) loops.
std::unique_ptr can only be moved, that means the source does not refer to the allocated object after the move to a new unique_ptr. Since the purpose of unique_ptr is to ensure that the owned object is deleted properly in all cases and never deleted twice, it makes sense that it cannot be blindly copied.
By using std::unique_ptr, you express that the parent "owns" the children, i.e. by copying the parent, you copy the children, by deleting the parent you delete the children.
This works nicely for trees, because every node has at most one parent, and you can probably take care of the roots.
If Part was representing a directed acyclic graph, you could use shared_ptr.
This is how I would write Part with hierarchical ownership:
#include <vector>
#include <memory>
class Part
{
public:
// or whatever constructor is useful
Part() = default;
~Part() = default;
// copy constructor needed because we cannot copy unique_ptr
Part(const Part &other) {
// cannot use just auto here, as that would try to copy the unique_ptrs
for(const auto &child_ptr : other.m_children) {
// we recursively copy all children
m_children.emplace_back(std::make_unique<Part>(*child_ptr));
}
}
// move constructor does what we expect
Part(Part && other) = default;
// since we need an explicit copy constructor it is
// good practice to mention also the assignment operators
// see also the "rule of five"
// copy assignment should be similar to the copy constructor, but first clear the children
Part &operator=(const Part &other) {
m_children.clear();
for(const auto &child_ptr : other.m_children) {
// we recursively copy all children
m_children.emplace_back(std::make_unique<Part>(*child_ptr));
}
return *this;
}
// moving should work as expected, we get all the children of other
Part &operator=(Part &&other) = default;
const std::vector<std::unique_ptr<Part>>& getChildren() const {
return m_children;
}
// we take a unique_ptr by value because it (the pointer) is small
void attachChild(std::unique_ptr<Part> child) {
m_children.push_back(std::move(child));
}
bool hasChildren() const {
return !m_children.empty();
}
private:
std::vector<std::unique_ptr<Part>> m_children;
};
// note how we return the vector by value,
// to avoid passing a stale reference
// the user will get a completely new vector
std::vector<Part> makeLotsOfParts(const Part &part) {
std::vector<Part> parts;
for(int i = 0; i < 10; ++i) {
// now we can copy parts!
parts.push_back(part);
}
// here the compiler will either apply the return value optimization
// or move the vector cheaply into the return value
return parts;
}
std::unique_ptr<Part> assemblePart() {
std::unique_ptr<Part> parent = std::make_unique<Part>();
std::unique_ptr<Part> child1 = std::make_unique<Part>();
// we do not need child1 any more, so we move from it
parent->attachChild(std::move(child1));
std::unique_ptr<Part> child2 = std::make_unique<Part>();
parent->attachChild(std::move(child2));
// again we can rely on RVO or move
return parent;
}