具有不完整类型和unique_ptr的树结构

Question

I have quick question regarding incomplete types and unique_ptr. I was trying to have a simple tree kinda structure which has been simplified here and I was getting a few compiler errors about incomplete types and what I knew was that I have to define the dtor which makes. Though that did not solve the issue, at least in msvc that I am testing it.

What I instead had to do was that for every class that required destruction of the incomplete types I had to just include the relevant header in the .cpp file. Defining explicitly the dtor did not help which was surprising to me.

Level1.h

#include "Level2Vector.h"

class Level1
{
public:
    Level1() : lvl2_vec(this) {}

private:
    Level2Vector lvl2_vec;
};

Level1.cpp

#include "Level2.h" // this was needed to not get the incomplete type
#include "Level3.h" // this was needed to not get the incomplete type 

Level2.h

#include "Level3Vector.h"

class Level1;

class Level2
{
public:
    Level2(Level1* const lvl1) : parent_(lvl1), lvl3_vec(this){}

private:
    Level1* parent_;
    Level3Vector lvl3_vec;
};

Level2.cpp

#include "Level2.h"
#include "Level3.h"  // this was needed to not get the incomplete type

Level3.h

class Level2;

class Level3
{
public:
    Level3(Level2* const lvl2) : parent_(lvl2) {}

private:
    Level2* parent_;
};

Level2Vector.h

class Level1;
class Level2;

class Level2Vector : public std::vector<std::unique_ptr<Level2>>
{
public:
    Level2Vector(Level1* lvl1) : parent_(lvl1) {}

private:
    Level1* parent_;
};

Level3Vector.h

class Level2;
class Level3;

class Level3Vector : public std::vector<std::unique_ptr<Level3>>

{
public:
    Level3Vector(Level2* lvl2) : parent_(lvl2) {}
    //~Level3Vector();

private:
    Level2* parent_;
};

Am I missing something ? Is every class that would potentially be using say Level2Vector need to include the Level2.h header ?

Answer 1

The type should be complete for the destructor, but the destructor is auto generated inline, so that mean that each place where the class is destroyed should have definition of the class own by std::unique_ptr .

The simpler to avoid this problem is to declare destructor for each class that have std::unique_ptr member. So:

class Level3Vector
{
public:
    explicit Level3Vector(Level2* lvl2) : parent_(lvl2) {}
    ~Level3Vector();

    // And so rule of 5
    Level3Vector(const Level3Vector&) = delete;
    Level3Vector& operator =(const Level3Vector&) = delete;

    Level3Vector(Level3Vector&&) = default;
    Level3Vector& operator =(Level3Vector&&) = default;

private:
    std::vector<std::unique_ptr<Level3>> lvl3s;
    Level2* parent; // or std::observer_ptr<Level2> parent;
};

And in cpp:

#include <Level3.h>

Level3Vector::~Level3Vector() = default;

Then destruction of Level3Vector in other classes doesn't require the include of <Level3.h> .

Answer 2

Generally speaking, you may use a forward-declared type (say in a header file you define a pointer using that type); but the definition of the type must be available before the definition of the type is needed. Eg in Level1.h you define an object of type Level2Vector (not a pointer to Level2Vector!); so Level1.h must include Level2Vector.h.

With that in mind, let's examine your question "Does every class that would potentially be using Level2Vector need to include the Level2.h header?" The answer is no. Level2.h provides the definition of class Level2. So the correct way to look at it is: a file (using Level2Vector or not) needs to include Level2.h, if the file needs the definition of Level2.