Чи знищить великий список переповнення моєї стеки?

Розглянемо таку реалізацію списку, що стосується окремо:

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

Тепер, припустимо, я припиняю використовувати якийсь std::unique_ptr<node> headекземпляр, який потім виходить за межі, викликаючи виклик його деструктора.

Чи вдасться це підірвати мій стек для достатньо великих списків? Чи справедливо припустити, що компілятор зробить досить складну оптимізацію (вбудований unique_ptrдеструктор в node's, а потім використовувати хвостову рекурсію), що стає набагато складніше, якщо я виконую наступне (оскільки dataдеструктор заблукає next, робить це важким щоб компілятор помітив потенційну можливість упорядкування та виклику хвоста):

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

Якщо dataякимось чином є вказівник на його, nodeто для рецидиву хвоста це може бути навіть неможливим (хоча, звичайно, ми повинні прагнути уникати таких порушень інкапсуляції).

Загалом, як тоді знищити цей список? Ми не можемо пройти через список та видалити "поточний" вузол, оскільки спільний вказівник не має release! Єдиний спосіб - із користувацьким делетером, який мені справді смердючий.

Так, це врешті-решт підіб'є ваш стек, якщо тільки компілятор не застосує оптимізацію хвостових викликів до nodedestructor і shared_ptr s destructor. Останнє вкрай залежить від стандартної реалізації бібліотеки. Наприклад, STL Майкрософт ніколи цього не зробить, оскільки shared_ptrспочатку декрементує опорний підрахунок свого керівника (можливо, знищує об'єкт), а потім зменшує контрольний номер контрольного блоку (слабкий відліку). Тож внутрішній деструктор - це не хвостик. Це також віртуальний дзвінок , що робить ще меншою ймовірність його оптимізації.

Типові списки вирішують цю проблему, не маючи одного вузла наступним, а маючи один контейнер, який володіє всіма вузлами, і використовує цикл, щоб видалити все в деструкторі.

Пізня відповідь, але оскільки ніхто її не надав ... Я зіткнувся з тією ж проблемою і вирішив її за допомогою спеціального деструктора:

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

Якщо у вас дійсно є список , тобто кожному вузлу передує один вузол і має максимум одного послідовника, а ваш list- вказівник на перший node, вищезгадане має працювати.

Якщо у вас є якась нечітка структура (наприклад, ациклічний графік), ви можете використовувати наступне:

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

Ідея полягає в тому, що коли ви робите:

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

Старий загальний покажчик nextзнищений (тому що його use_countзараз є 0), і ви вказуєте на наступне. Це робить точно так само, як деструктор за замовчуванням, за винятком того, що він робить це ітеративно замість рекурсивно і, таким чином, уникає переповнення стека.

Якщо чесно, я не знайомий з алгоритмом розбиття інтелектуальних покажчиків будь-якого компілятора C ++, але я можу уявити простий, нерекурсивний алгоритм, який це робить. Врахуйте це:

• У вас черга розумних покажчиків чекає на розселення.
• У вас є функція, яка приймає перший вказівник і розміщує його, і повторює це, доки черга не буде порожньою.
• Якщо розумний вказівник потребує розстановки, його заштовхують у чергу, і вищевказана функція викликається.

Отже, не буде шансу стек переповнюватись, і набагато простіше оптимізувати рекурсивний алгоритм.

Я не впевнений, чи вписується це у філософію "розумних покажчиків майже з нульовою вартістю".

Я б здогадався, що те, що ви описали, не спричинить переповнення стека, але ви можете спробувати сконструювати розумний експеримент, щоб довести мене неправильно.

ОНОВЛЕННЯ

Ну, це доводить неправильність того, що я писав раніше:

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

Ця програма вічно будує і деконструює ланцюг вузлів. Це викликає переповнення стека.