C ++ Asignación de este puntero de una clase a un unique_ptr o shared_ptr

Tengo una clase base de la que quiero heredar y antes de que cualquiera de sus clases derivadas pueda declararse, al menos 1 instancia de la clase base debe declararse primero. Estaba pensando en almacenar elthis pointer de la clase base en su propia variable miembro de un unique_ptr en lugar de usar unstatic_ptr. Además, la clase base realizará un seguimiento de todas las instancias de sus clases derivadas hasta que se declare otra clase base. Así es como se ven mis declaraciones de clase:

#include <vector>
#include <map>
#include <memory>
#include <string>

class Parent {
public: {
    enum ChildType {
        CHILD_NONE = 0,
        CHILD_A,
        CHILD_B,
        CHILD_C,
     }; // ChildType

protected:
    ChildType type_; // Type of Child Class when inheritance is used
    std::string childName_; // Name of Child Class when inheritance is used

private:
    const std::string myName_; // Name of this parent class
    bool parentConstructed_ = false; // Flag if this parent was constructed

    const static Parent* s_firstParent_; // static pointer
    std::unique_ptr<Parent>  me_; // Or
    std::shared_ptr<Parent>  me_;

    // Some Typedefs for containers
    typedef std::vector<std::shared_ptr<Parent>> Children;
    typedef std::vector<std::shared_ptr<Parent>> OtherParents;
    typedef std::vector<std::shared_ptr<Parent>> Siblings;

    typedef std::vector<std::string> Names;
    typedef Names ChildrenNames, OtherParentsNames, SiblingsNames;

    // Containers and map associations of names.
    Children children_;
    ChildrensNames namesOfChildren_;
    std::map< ChildrensNames, Children > mapChildren_;

    OtherParents otherParents_;
    OtherParentsNames associatedParentsNames_;
    std::map< OtherParentsNames, OtherParents > mapParents_;

    Siblings siblings_;
    SiblingsNames namesOfSiblings_;
    std::map< SiblingsNames, Siblings > mapSiblings_;

public:
    // This constructor must be called at least once as a base class instantiation
    // Before Any of its derived members can be declared.
    explicit Parent( const std::string& parentName );

    // Other necessary constructors and operators for move semantics
    Parent( Parent &&self );
    Parent& operator=( Parent &transfer );

    Parent( Parent const& ) = delete;
    Parent& operator=( Parent const & ) = delete;

    // Other functions that are part of the public interface that
    // may be overridden by the inherited types
    virtual void printName() const; 
    const std::string& getName() const;

    // Other public methods that are common among all types including
    // derived and base types.

protected:
    // Constructor Signature to be Used for Derived Types
    Parent( const std::string& parentName, std::string& childName, ChildType type );

    // Other Protected Members for use with derived types
};

Todos los tipos derivados heredarán públicamente de esta base, tales como:

class ChildA : public Parent {
public:
    ChildA( const std::string& parentName, std::string& myName, ChildType type );
};

La idea que tengo en mente para usar esta jerarquía de clases en mi main sería la siguiente

#include "ChildA.h"
#include "ChildB.h"
#include "ChildC.h"

int main() {
    // If we try to do this:
    ChildA a( std::string( "Parent" ), std::string( "ChildA" ), Parent::ChildType::CHILD_A );
    // The Last parameter would not be needed to be set since that would
    // be done automatically by default for all derived types, but just shown here for demonstrative purposes.

    // This construction of derived type would throw an exception because at
    // least one base was not declared.

    // This must be done first:
    Parent parent( std::string( "Parent1" );
    // Then this would be valid
    ChildA a( std::string( "Parent1" ), std::string( "ChildA" ) );
    ChildB b( std::string( "Parent1" ), std::string( "ChildB" ) );

    // Then if we created a 2nd parent base
    Parent parent2( std::string( "Parent2" );
    // The next set of child classes might be nested under this parent since
    // it is a 2nd instance and the name doesn't match.
    // if one was to call this constructor above as is but passed in 
    // the same string as from a previous instance it would also throw an exception.

    // In this next line of code it would not necessarily be nested automatically
    // to Parent2 because it would check the string name passed in for the
    // parents name and nest it accordingly if it found that string.
    ChildC c( std::string( "Parent1 or 2" ), std::string( "ChildC" ) );          

    return 0;    
}

Sí sé cómo crear un puntero estático con una función estática para que el puntero de este de la clase tenga solo una instancia del mismo durante el tiempo de ejecución de la aplicación. Solo quiero saber si hay un lugar para usar shared_ptr o unique_ptr en su lugar y después de crear con éxito al menos una instancia de un tipo base primero y luego guardar el (este) puntero en cualquier tipo de puntero inteligente. Prefería hacer un único donde la clase padre "posee" su propio puntero.

Si necesita más información, hágamelo saber y actualizaré esta pregunta según lo solicitado, como mostrar la definición del constructor de mi clase base.