Büyük bir listeyi tahrip etmek yığımı taşacak mı?

Aşağıdaki tek bağlantılı liste uygulamasını düşünün:

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

Şimdi diyelim std::unique_ptr<node> headki daha sonra kapsam dışı olan ve yıkıcısının çağrılmasına neden olan bir örneği kullanmayı bırakıyorum.

Bu, yığınımı yeterince büyük listeler için patlatacak mı? Adil derleyici (inline oldukça karmaşık optimizasyon yapacak varsaymak mı unique_ptr'içine s yıkıcı nodebunu yaparsam beri takip (çok zor aldığı halde, s' kuyruk Özyinelemeyi kullanın) datayıkıcı obfuscate ediyorum next, 'ın zor hale getirmekte derleyicinin olası yeniden sıralama ve kuyruk arama fırsatını fark etmesi için):

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

Bir dataşekilde bir işaretçisi varsa node, kuyruk özyineleme için bile imkansız olabilir (tabii ki bu tür kapsülleme ihlallerinden kaçınmaya çalışmalıyız).

Genel olarak, başka türlü bu listeyi nasıl yok edecek? Listede dolaşamayız ve "geçerli" düğümü silemeyiz, çünkü paylaşılan işaretçide bir release! Tek yol, benim için gerçekten kötü kokulu özel bir silme ile.

Evet, derleyici node'yıkıcıya ve shared_ptr ' yıkıcısına sadece bir kuyruk çağrısı optimizasyonu uygulamadığı sürece, bu, sonunda yığınızı havaya uçuracaktır . İkincisi, standart kütüphane uygulamasına son derece bağımlıdır. Örneğin, Microsoft'un shared_ptrSTL'si bunu asla yapmayacaktır, çünkü ilk önce sivrisinekinin referans sayısını azaltır (muhtemelen nesneyi yok eder) ve daha sonra kontrol bloğunun referans sayısını (zayıf referans sayısı) azaltır. Yani iç yıkıcı kuyruk çağrısı değildir. Aynı zamanda sanal bir çağrıdır , bu da optimize edilme olasılığını azaltır.

Tipik listeler, bir düğümü diğerine sahip olmadan, ancak tüm düğümlere sahip olan ve yıkıcıdaki her şeyi silmek için bir döngü kullanan bir sorunla bu sorunu çözer.

Geç cevap ama kimse bunu sağlamadığından ... Ben aynı sorunla karşılaştım ve özel bir yıkıcı kullanarak çözdüm:

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

Gerçekten bir listeniz varsa , yani her düğümden önce bir düğüm gelir ve en fazla bir takipçisi varsa ve listilkiniz için bir işaretçiyseniz node, yukarıdakilerin çalışması gerekir.

Bazı bulanık yapılarınız varsa (örneğin asiklik grafik), aşağıdakileri kullanabilirsiniz:

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

Fikir şu ki:

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

Eski paylaşılan işaretçi nextyok edildi ( use_countşimdi olduğu için 0) ve aşağıdakilere işaret ediyorsunuz. Bu, varsayılan yıkıcıyla tamamen aynıdır, ancak yinelemeli olarak yinelemeli olarak yapar ve böylece yığın taşmasını önler.

Dürüst olmak gerekirse, herhangi bir C ++ derleyicisinin akıllı işaretçi ayırma algoritmasına aşina değilim, ancak bunu yapan basit, özyinelemesiz bir algoritma hayal edebiliyorum. Bunu düşün:

• Yeniden konumlandırmayı bekleyen akıllı işaretçiler kuyruğunuz var.
• İlk işaretçiyi alan ve onu yeniden konumlandıran ve kuyruk boşalana kadar bunu tekrarlayan bir işleviniz var.
• Akıllı bir işaretçinin yeniden konumlandırılması gerekiyorsa, sıraya itilir ve yukarıdaki işlev çağrılır.

Bu nedenle, yığının taşması için bir şans olmaz ve özyinelemeli bir algoritmayı optimize etmek çok daha kolaydır.

Bunun "neredeyse sıfır maliyetli akıllı işaretçiler" felsefesine uyup uymadığından emin değilim.

Açıkladığınız şeyin yığın taşmasına neden olmayacağını tahmin ediyorum, ancak yanlış olduğunu kanıtlamak için akıllı bir deney oluşturmayı deneyebilirsiniz.

GÜNCELLEME

Bu, daha önce yazdıklarımın yanlış olduğunu kanıtlıyor:

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

Bu program sonsuza dek bir düğüm zinciri oluşturur ve bir yapı zinciri oluşturur. Yığın taşmasına neden olur.