First of all, I like to use the concept of a "master" shared_ptr. That is, I
attempt to design my architectures so that there is one shared_ptr which persists for the lifetime of the object being pointed to; other shared_ptrs are transient, in that they persist for a shorter period of time (typically which a particular piece of work is being performed). To pursue the metaphor, the "master" shared_ptr holds its object in existence. It is the pointer which (when reset) ultimately causes the object to be deleted.
Using this concept, my parent object holds the master shared_ptr of its
child. (Typically there are multiple children and their master shared_ptrs are stored in a vector.) The child holds a weak_ptr to its parent. In my work, typically both parent and child inherit from enable_shared_from_this.
The "trick" is to treat the parent-child relationship seriously. Since child
objects do not exist except in the context of a parent, it is logical to create a function member of the parent which is responsible for creating the child and establishing linkages. (Or, if this needs to occur elsewhere, the child is constructed by some other [third-party] object's member function which creates the child and links the child and parent together.) It should not be necessary to construct the child in the parent's constructor, nor should it be necessary to establish linkages with the parent in the child's constructor. The problems you are concerned about need not exist. As long as the construction of the child and its linkage to its parent occur in a single member-function, it should not be necessary for either the parent's or the child's constructor to be responsible for establishing the linkage. what you ultimately describe is a 2 phase construction. If the invariant of your class is that the parent is only valid if it also has its required children, only after the second phase the invariant of the parent can be checked. Although 2 phase construction is regarded as a bad thing, I think it can not be circumvented in every situation (e.g. 2 phase construction allows polymorphic behavior and sometimes you need to make first A then B and then link). During construction and destruction (or in general during change) objects may be in an inconsistent state and dependent objects should be careful then.