Akankah merusak daftar besar meluap tumpukan saya?

Pertimbangkan penerapan daftar tertaut tunggal berikut:

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

Sekarang, misalkan saya berhenti menggunakan beberapa std::unique_ptr<node> headcontoh yang kemudian keluar dari ruang lingkup, menyebabkan destruktornya dipanggil.

Apakah ini akan menghancurkan tumpukan saya untuk daftar yang cukup besar? Apakah adil untuk menganggap bahwa kompiler akan melakukan optimasi yang cukup rumit (inline unique_ptr's destructor ke node' s, kemudian menggunakan rekursi ekor), yang menjadi lebih sulit jika saya melakukan hal berikut (karena datadestructor akan mengaburkan next, membuat sulit bagi kompiler untuk melihat potensi pemesanan ulang dan peluang panggilan balik):

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

Jika dataentah bagaimana memiliki pointer ke nodemaka mungkin bahkan tidak mungkin untuk rekursi ekor (meskipun tentu saja kita harus berusaha untuk menghindari pelanggaran enkapsulasi semacam itu).

Secara umum, bagaimana seharusnya seseorang menghancurkan daftar ini? Kami tidak dapat menelusuri daftar dan menghapus simpul "saat ini" karena pointer yang dibagikan tidak memiliki release! Satu-satunya cara adalah dengan custom deleter, yang benar-benar bau bagi saya.

Ya, ini pada akhirnya akan meledakkan tumpukan Anda, kecuali jika kompiler kebetulan menerapkan optimasi panggilan ekor ke nodedestruktor dan shared_ptr destruktor. Yang terakhir ini sangat tergantung pada implementasi perpustakaan standar. STL Microsoft, misalnya, tidak akan pernah melakukan itu, karena shared_ptrpertama-tama mengurangi jumlah referensi yang ditunjuknya (mungkin menghancurkan objek) dan kemudian mengurangi jumlah referensi blok kontrolnya (jumlah referensi yang lemah). Jadi destruktor dalam bukan panggilan ekor. Ini juga panggilan virtual , yang membuatnya semakin kecil kemungkinannya untuk dioptimalkan.

Daftar tipikal mengatasi masalah itu dengan tidak memiliki satu node yang memiliki berikutnya, tetapi dengan memiliki satu wadah yang memiliki semua node, dan menggunakan loop untuk menghapus semua yang ada di destructor.

Jawaban terlambat tetapi karena tidak ada yang menyediakannya ... Saya mengalami masalah yang sama dan menyelesaikannya dengan menggunakan destruktor khusus:

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

Jika Anda benar-benar memiliki daftar , yaitu setiap node didahului oleh satu node dan memiliki paling banyak satu pengikut, dan Anda listadalah pointer ke yang pertama node, di atas akan berfungsi.

Jika Anda memiliki struktur fuzzy (misalnya grafik asiklik), Anda dapat menggunakan yang berikut:

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

Idenya adalah ketika Anda melakukannya:

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

Pointer bersama yang lama nextdihancurkan (karena use_countsekarang 0), dan Anda menunjuk ke berikut ini. Ini tidak persis sama dengan destruktor default, kecuali ia melakukannya berulang bukan secara rekursif dan dengan demikian menghindari stack overflow.

Sejujurnya saya tidak terbiasa dengan algoritma deallokasi pointer pintar dari setiap kompiler C ++, tapi saya bisa membayangkan algoritma sederhana, non-rekursif yang melakukan ini. Pertimbangkan ini:

• Anda memiliki antrean smart pointer yang menunggu deallokasi.
• Anda memiliki fungsi yang mengambil pointer pertama dan membatalkan alokasi itu, dan ulangi ini sampai antrian kosong.
• Jika smart pointer membutuhkan deallokasi, maka akan didorong ke antrian dan fungsi di atas dipanggil.

Oleh karena itu tidak akan ada kesempatan untuk stack meluap, dan itu jauh lebih sederhana yang mengoptimalkan algoritma rekursif.

Saya tidak yakin apakah ini cocok dengan filosofi "pointer cerdas hampir nol biaya".

Saya akan menebak bahwa apa yang Anda uraikan tidak akan menyebabkan stack overflow, tetapi Anda dapat mencoba membuat eksperimen yang cerdas untuk membuktikan bahwa saya salah.

MEMPERBARUI

Nah, ini membuktikan salah apa yang saya tulis sebelumnya:

#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;
}

Program ini secara kekal membangun, dan mendekonstruksi rantai simpul. Itu menyebabkan stack overflow.