Eu tenho um número de longas listas vinculadas (elas têm até 20.000 itens). Eles têm origens diferentes, mas podem eventualmente apontar para o mesmo nó de algum nó em diante. Decidi deixar essa lista vinculada crescer junto e compartilhar a memória entre eles.

É por isso que decidi implementar uma lista vinculada com ponteiros compartilhados:

#include <memory>
struct SharedLinkedList {
    int someData;
    std::shared_ptr<SharedLinkedList> next;
};

Desta forma tudo funciona bem. As listas vinculadas que não são mais necessárias são excluídas. Se eles compartilharem alguma parte com outra lista vinculada, somente sua parte não compartilhada será excluída.

O problema aparece quando mais listas vinculadas sem partes compartilhadas estão prestes a ser excluídas. A exclusão começa com o primeiro elemento. Isso diminui o número de referências para o próximo elemento que também pode ser excluído e isso se repete recursivamente até que a pilha estourar.

Aqui está o exemplo de código que cria uma longa lista vinculada e, em seguida, falha ao excluí-la.

SharedLinkedList* beginningOfList;
SharedLinkedList* actualElement = new SharedLinkedList();
SharedLinkedList* nextElement;

beginningOfList = actualElement;
for (int i = 0; i < 1000; i++) { // 100 is OK, 1000 is KO
    nextElement = new SharedLinkedList();
    actualElement->next = std::shared_ptr<SharedLinkedList>(nextElement);
    actualElement = nextElement;
}
delete beginningOfList;

Agradeço antecipadamente por qualquer um dos seguintes:

Explicação de shared_pointers e do que estou perdendo. Como posso usá-los? E isso pode ser feito usando-os? Esse compartilhamento de memória não é a coisa pela qual os indicadores de ações foram inventados?conselhos sobre como reimplementar meu códigoEste código será usado para cálculos científicos que serão executados no meu computador. Posso ajustar algo de alguma forma para ter um tamanho maior de pilha?

Note que esta questão não é específica para o c ++ 11. Eu não me importo com qual implementação de pontos compartilhados é usada. Eu até implementei meus próprios indicadores compartilhados. Isso me permitiu ter um pouco mais de listas encadeadas, mas a recursão em destruidores e transbordamento de pilha também apareceu. E eu não vejo nenhuma maneira como poderiam ser compartilhados ponteiros implementados sem recursão em destruidores.

EDITAR:

Apenas para evitar confusões: quero repetir que todas as listas podem ser compartilhadas. Então, alguém poderia chamá-las de árvores.

Aqui está o exemplo:

list1 contém: 1,2,3,4,5,6,7.

list2 contém: 6,6,6,1,2,3,4,5,6,7

list3 contém: 10,11,12,1,2,3,4,5,6,7

Eu quero representar isso em 3 SharedLinkedList que não desperdice momory por armazenar 1,2,3,4,5,6,7 várias vezes, mas eles apontam para o mesmo lugar. É por isso que a contagem de referência é necessária.

delete list3; é suposto para apagar apenas a parte que não é compartilhada, ou seja, elementos 10,11,12.