A destruição de uma lista grande sobrecarregará minha pilha?

Considere a seguinte implementação de lista vinculada única:

struct node {
    std::unique_ptr<node> next;
    ComplicatedDestructorClass data;
}

Agora, suponha que eu pare de usar alguma std::unique_ptr<node> headinstância que fica fora do escopo, fazendo com que seu destruidor seja chamado.

Isso vai explodir minha pilha para listas suficientemente grandes? É justo supor que o compilador faça uma otimização bastante complicada ( unique_ptro destruidor do inline para o node's' e depois use a recursão da cauda), o que fica muito mais difícil se eu fizer o seguinte (já que o datadestruidor ofuscaria nexto do, tornando difícil para o compilador perceber as possíveis oportunidades de reordenação e chamada final):

struct node {
    std::shared_ptr<node> next;
    ComplicatedDestructorClass data;
}

Se de dataalguma forma tem um ponteiro para nodeisso, pode até ser impossível a recursão da cauda (embora, é claro, devamos nos esforçar para evitar tais violações do encapsulamento).

Em geral, como alguém deveria destruir essa lista, então? Não podemos percorrer a lista e excluir o nó "atual" porque o ponteiro compartilhado não possui um release! A única maneira é com um deleter personalizado, que é realmente fedorento para mim.

Sim, isso acabará com sua pilha, a menos que o compilador aplique uma otimização de chamada de cauda ao nodedestruidor e shared_ptr destruidor. O último é extremamente dependente da implementação da biblioteca padrão. O STL da Microsoft, por exemplo, nunca fará isso, porque shared_ptrprimeiro diminui a contagem de referência de seu pontapé (possivelmente destruindo o objeto) e depois diminui a contagem de referência de seu bloco de controle (a contagem fraca de referência). Portanto, o destruidor interno não é um chamado final. Também é uma chamada virtual , o que torna ainda menos provável que ela seja otimizada.

As listas típicas resolvem esse problema por não ter um nó próprio no próximo, mas por um contêiner que possui todos os nós e usa um loop para excluir tudo no destruidor.

Resposta tardia, mas como ninguém a forneceu ... Encontrei o mesmo problema e o resolvi usando um destruidor personalizado:

virtual ~node () throw () {
    while (next) {
        next = std::move(next->next);
    }
}

Se você realmente tem uma lista , ou seja, todo nó é precedido por um nó e tem no máximo um seguidor, e você listé um ponteiro para o primeiro node, o que precede deve funcionar.

Se você possui alguma estrutura difusa (por exemplo, gráfico acíclico), pode usar o seguinte:

virtual ~node () throw () {
    while (next && next.use_count() < 2) {
        next = std::move(next->next);
    }
}

A ideia é que quando você faz:

next = std::move(next->next);

O ponteiro compartilhado antigo nexté destruído (porque use_countagora é 0) e você aponta para o seguinte. Isso faz exatamente o mesmo que o destruidor padrão, exceto o iterativamente, em vez de recursivamente, evitando assim o estouro da pilha.

Para ser sincero, não estou familiarizado com o algoritmo de desalocação de ponteiros inteligentes de qualquer compilador C ++, mas posso imaginar um algoritmo simples e não recursivo que faz isso. Considere isto:

• Você tem uma fila de ponteiros inteligentes aguardando a desalocação.
• Você tem uma função que pega o primeiro ponteiro e o desaloca e repete isso até que a fila esteja vazia.
• Se um ponteiro inteligente precisar de desalocação, ele será empurrado para a fila e a função acima será chamada.

Portanto, não haveria chance da pilha transbordar, e é muito mais simples otimizar um algoritmo recursivo.

Não tenho certeza se isso se encaixa na filosofia "quase zero custo de ponteiros inteligentes".

Eu acho que o que você descreveu não causaria estouro de pilha, mas você poderia tentar construir um experimento inteligente para provar que estava errado.

ATUALIZAR

Bem, isso prova errado o que escrevi anteriormente:

#include <iostream>
#include <memory>

using namespace std;

class Node;

Node *last;
long i;

class Node
{
public:
   unique_ptr<Node> next;
   ~Node()
   {
     last->next.reset(new Node);
     last = last->next.get();
     cout << i++ << endl;
   }
};

void ignite()
{
    Node n;
    n.next.reset(new Node);
    last = n.next.get();
}

int main()
{
    i = 0;
    ignite();
    return 0;
}

Esse programa cria eternamente e desconstrói uma cadeia de nós. Isso causa excesso de pilha.