การทำลายรายการใหญ่จะล้นสแต็กของฉันหรือไม่

พิจารณาการใช้งานรายการที่เชื่อมโยงโดยลำพังดังต่อไปนี้:

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

ทีนี้สมมติว่าฉันหยุดใช้std::unique_ptr<node> headอินสแตนซ์ที่เกินขอบเขตแล้วทำให้ destructor ของมันถูกเรียก

สิ่งนี้จะทำให้สแตกของฉันสำหรับรายการขนาดใหญ่เพียงพอหรือไม่ มันยุติธรรมที่จะคิดว่าคอมไพเลอร์จะทำเพิ่มประสิทธิภาพซับซ้อนสวย (อินไลน์unique_ptr's destructor เข้าnode' s แล้วใช้ recursion หาง) ซึ่งได้รับยากมากถ้าผมทำต่อไปนี้ (ตั้งแต่datadestructor จะทำให้งงงวยnext's ทำให้มันยาก เพื่อให้คอมไพเลอร์สังเกตเห็นโอกาสการเรียงลำดับใหม่และโอกาสในการโทรหาง):

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

ถ้าdataอย่างใดมีตัวชี้ไปnodeแล้วก็อาจเป็นไปไม่ได้สำหรับการเรียกซ้ำหาง (แม้ว่าแน่นอนเราควรพยายามหลีกเลี่ยงการละเมิด encapsulation ดังกล่าว)

โดยทั่วไปแล้วเราจะทำลายรายการนี้ได้อย่างไร? เราไม่สามารถข้ามผ่านรายการและลบโหนด "ปัจจุบัน" เนื่องจากตัวชี้ที่ใช้ร่วมกันไม่มีrelease! วิธีเดียวคือกับตัวกำหนดเองซึ่งส่งกลิ่นให้ฉันจริงๆ

ใช่สิ่งนี้จะทำให้สแตกของคุณในที่สุดเว้นแต่ว่าคอมไพเลอร์เพิ่งเกิดขึ้นเพื่อใช้การเพิ่มประสิทธิภาพการโทรหางกับตัวnodeทำลายและตัว shared_ptrทำลายของ สิ่งหลังขึ้นอยู่กับการใช้งานไลบรารีมาตรฐานอย่างมาก ตัวอย่างเช่น STL ของ Microsoft จะไม่ทำเช่นนั้นเพราะจะshared_ptrลดจำนวนการอ้างอิงของปวง (ก่อนที่จะทำลายวัตถุ) จากนั้นลดจำนวนการอ้างอิงของบล็อกควบคุม (จำนวนการอ้างอิงที่อ่อนแอ) ดังนั้นตัวทำลายภายในจึงไม่ใช่การเรียกหาง นอกจากนี้ยังเป็นสายเสมือนซึ่งทำให้มีโอกาสน้อยที่จะได้รับการปรับให้เหมาะสม

รายการทั่วไปจะแก้ไขปัญหานั้นได้โดยไม่มีโหนดตัวใดตัวหนึ่งเป็นเจ้าของตัวถัดไป แต่ด้วยการมีหนึ่งคอนเทนเนอร์ที่เป็นเจ้าของโหนดทั้งหมดและใช้วนรอบเพื่อลบทุกอย่างใน destructor

คำตอบที่ล่าช้า แต่เนื่องจากไม่มีใครให้ ... ฉันพบปัญหาเดียวกันและแก้ไขโดยใช้ destructor แบบกำหนดเอง:

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 ++ ใด ๆ แต่ฉันสามารถจินตนาการอัลกอริธึมที่เรียบง่ายและไม่เรียกซ้ำได้ พิจารณาสิ่งนี้:

• คุณมีคิวพอยน์เตอร์อัจฉริยะรอการจัดสรรคืน
• คุณมีฟังก์ชั่นที่ใช้ตัวชี้แรกและยกเลิกการจัดสรรและทำซ้ำสิ่งนี้จนกว่าคิวจะว่างเปล่า
• หากตัวชี้สมาร์ทต้องการยกเลิกการจัดสรรตำแหน่งจะถูกส่งไปยังคิวและเรียกใช้ฟังก์ชันข้างต้น

ดังนั้นจึงไม่มีโอกาสที่สแต็กจะโอเวอร์โฟลว์และมันง่ายกว่ามากที่จะปรับอัลกอริทึมแบบเรียกซ้ำ

ฉันไม่แน่ใจว่าสิ่งนี้สอดคล้องกับปรัชญา "ตัวชี้สมาร์ทราคาเกือบเป็นศูนย์" หรือไม่

ฉันเดาว่าสิ่งที่คุณอธิบายจะไม่ทำให้เกิดการล้นสแต็ค แต่คุณสามารถลองสร้างการทดสอบที่ชาญฉลาดเพื่อพิสูจน์ว่าฉันผิด

UPDATE

นี่เป็นข้อผิดพลาดที่ฉันเขียนไว้ก่อนหน้านี้:

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

โปรแกรมนี้สร้างขึ้นชั่วนิรันดร์และแยกแยะสายโซ่ของโหนด มันทำให้เกิดการล้นสแต็ค