Enable_shared_from_this deve ser a primeira classe base?

Minha classe herda de várias bases, uma das quais é std::enable_shared_from_this. Deve ser a primeira base?

Suponha o seguinte código de exemplo:

struct A { ~A(); };
struct B { ~B(); };
struct C : A, B, std::enable_shared_from_this<C> {};

std::make_shared<C>(); 

Quando ~A()e ~B()executar, posso ter certeza de que o armazenamento onde Cmorava ainda está presente?

Quando ~A()e ~B()executar, posso ter certeza de que o armazenamento onde Cmorava ainda está presente?

Claro! Seria difícil usar uma classe base que tenta liberar sua própria memória (a memória em que reside). Não tenho certeza se é formalmente legal.

As implementações não fazem isso: quando a shared_ptr<T>é destruída ou redefinida, a contagem de referência (RC) da propriedade compartilhada de Té diminuída (atomicamente); se alcançou 0 no decremento, a destruição / exclusão de Té iniciada.

Então, a contagem de proprietários fracos-ou-T-existe é diminuída (atomicamente), como Tnão existe mais: precisamos saber se somos a última entidade interessada no bloco de controle; se o decréscimo der um resultado diferente de zero, significa weak_ptrque existem alguns que compartilham (podem ser 1 compartilhamento ou 100%) de propriedade do bloco de controle e agora são responsáveis ​​pela desalocação.

De qualquer forma, em algum momento, o decremento atômico terminará com um valor zero, para o último coproprietário.

Aqui não há tópicos, não-determinismo e, obviamente, o último weak_ptr<T>foi destruído durante a destruição de C. (A suposição não escrita em sua pergunta é que nenhum outro weak_ptr<T>foi mantido.)

A destruição sempre acontece nessa ordem exata . O bloco de controle é usado para destruição, pois não se shared_ptr<T>sabe (em geral) qual destruidor (potencialmente não virtual) da classe (potencialmente diferente) mais derivada a ser chamada . (O bloco de controle também sabe não desalocar a memória na contagem compartilhada atingindo zero para make_shared.)

A única variação prática entre implementações parece ser sobre os detalhes finos de cercas de memória e evitar algumas operações atômicas em casos comuns.

Quando ~ A () e ~ B () são executados, posso ter certeza de que o armazenamento em que C morava ainda está presente?

Não, e a ordem das classes base é irrelevante. Até o uso (ou não) de enable_shared_from_this é irrelevante.

Quando um objeto C é destruído (não importa o que aconteça), ~C()ele será chamado antes de ambos ~A()e ~B(), dessa maneira, os destruidores de base funcionam. Se você tentar "reconstruir" o objeto C no destruidor de base e acessar os campos nele, esses campos já foram destruídos, portanto, você terá um comportamento indefinido.

Se você criar um objeto c do tipo C, com as bases A, B e um contador de referência através da herança da base enable_shared_from_this<T>, primeiro a memória será alocada para todo o objeto resultante, incluindo as bases em geral e a base enable_shared_from_this<T>. O objeto não será destruído até que o último proprietário (também conhecido como shared_ptr) renuncie à propriedade. Nesse momento ~ enable_shared ..., ~ B e ~ A serão executados após ~ C. A memória alocada completa ainda está garantida para estar lá até após a execução do último destruidor ~ A. Depois que ~ A é executado, a memória completa do objeto é liberada de uma só vez. Então, para responder sua pergunta:

Quando ~ A () e ~ B () são executados, posso ter certeza de que o armazenamento em que C morava ainda está presente?

Sim, embora você não possa acessá-lo legalmente, mas por que você precisaria saber? Que problema você está tentando evitar?