How to safely store a reference to owner in an owned C++ object?

Question

Class Owner owns multiple objects of class Item via unique_ptr. I want objects of Item to store a reference (not a pointer) to the Owner objects which owns them, with the following requirements:

1. There can never be a dangling reference.

2. The reference contained in an itm object of class Item never points to an Owner object which does not own itm.

3. An Item object always has an owner.

4. Item class will be used via its subclasses.

I tried automatically registering the objects of Item class during construction (in Item::Item()), but it leads to double deletion when they're created on the stack. Hence, I probably need to prevent them being created on the stack. But that's a problem when I am subclassing them. Is there an easier way of ensuring that the mutual links are always correct, without relaxing any of the requirements? I suspect that 3. might have to be relaxed, to enable creating the object first and registering it with the Owner later.

Answer 1

To elaborate on my comment, if you make Items constructor private, and take the reference to the owner on construction. Then you can make Owner a friend class, or as in my example make one of Owners function a friend function.

This way Items can only be created here and nowhere else. When they get created they get the reference to the Owner directly.

The reference in Item will always be valid, since when the Owner gets destroyed the Items it owns are destroyed with it.

#include <iostream>
#include <vector>
#include <memory>

class Item;

class Owner {
    public:
    std::vector<std::unique_ptr<Item>> foos;

    void makeItem();
};

class Item {
    Item(Owner& b) : owner(b) {}

    friend void Owner::makeItem();
    Owner& owner;
};

void Owner::makeItem() {
    foos.emplace_back(new Item(*this));
}

int main() {
    Owner b;
    //Item item(b); not allowed, constructor is private
    b.makeItem();
}

Not completely sure what you mean with point 4.