Bir paylaşılan_ptr değerini referans veya değere göre geçmeli miyiz?

Bir işlev bir shared_ptr(boost veya C ++ 11 STL'den) aldığında , geçiyor musunuz:

• const referansı ile: void foo(const shared_ptr<T>& p)

• veya değerine göre: void foo(shared_ptr<T> p)?

İlk yöntemi tercih ederim çünkü daha hızlı olacağından şüpheleniyorum. Ama bu gerçekten buna değer mi yoksa başka sorunlar var mı?

Lütfen seçiminizin nedenlerini veya durumun neden önemli olmadığını düşündüğünüzü açıklar mısınız?

Bu soru Scott, Andrei ve Herb tarafından C ++ ve Ötesinde 2011'de Bize Sorun oturumu sırasında tartışılmış ve cevaplanmıştır . 4:34 dan İzle üzerinde performans ve doğruluğu .shared_ptr

Kısacası, amaç bir nesnenin sahipliğini (örneğin farklı veri yapıları arasında veya farklı evreler arasında) paylaşmak olmadıkça değere göre geçmek için bir neden yoktur .

Yukarıda bağlantılı konuşma videosunda Scott Meyers tarafından açıklandığı gibi taşıyabilir veya optimize edemezseniz, ancak bu, kullanabileceğiniz C ++ 'ın gerçek sürümüyle ilgilidir.

Bu tartışmaya önemli bir güncelleştirme sırasında yaşandı GoingNative 2012 Konferansın İnteraktif Panel: Bize şey sor! izlemeye değer, özellikle de 22:50 .

İşte Herb Sutter'in alımı

Kılavuz: Sahipliği paylaşmak veya aktarmak gibi akıllı işaretçiyi kullanmak veya değiştirmek istemiyorsanız, akıllı işaretçiyi işlev parametresi olarak geçirmeyin.

Yönerge: Bir işlevin bir yığın-değer paylaşılan_ptr parametresi kullanarak bir yığın nesnesinin sahipliğini depolayıp paylaşacağını ifade edin.

Yönerge: Yalnızca paylaşılan_ptr değerini değiştirmek için const olmayan bir paylaşılan_ptr ve parametresi kullanın. Const shared_ptr & parametresini yalnızca kopyasını alıp paylaşmayacağınızdan emin değilseniz ve sahiplik paylaşıp paylaşmayacağınız konusunda parametre olarak kullanın; aksi halde widget * kullanın (veya nullable değilse bir widget & kullanın).

Şahsen bir constreferans kullanırdım . Bir işlev çağrısı uğruna sadece azaltmak için referans sayısını artırmaya gerek yoktur.

Tarafından geçmek constdaha da hızlı referans. Saklamanız gerekiyorsa, bazı kaplarda, ref. sayım kopyalama işlemi tarafından otomatik olarak artırılacaktır.

Bir keresinde, aşağıdaki kodu koştum fooalarak shared_ptrtarafından const&tekrar birlikte fooalarak shared_ptrdeğerine göre.

void foo(const std::shared_ptr<int>& p)
{
    static int x = 0;
    *p = ++x;
}

int main()
{
    auto p = std::make_shared<int>();
    auto start = clock();
    for (int i = 0; i < 10000000; ++i)
    {
        foo(p);
    }    
    std::cout << "Took " << clock() - start << " ms" << std::endl;
}

Intel core 2 dörtlü (2.4GHz) işlemcimde VS2015, x86 yayın derlemesi kullanma

const shared_ptr&     - 10ms  
shared_ptr            - 281ms 

Değere göre kopyalama sürümü, daha yavaş bir büyüklük sırasıydı.
Geçerli evre ile eşzamanlı olarak bir işlev arıyorsanız, const&sürümü tercih edin .

C ++ 11 beri const üzerinde değer ve düşündüğünüzden daha sık almalısınız .

Std :: shared_ptr (altta yatan T türü yerine) alıyorsanız, bununla bir şey yapmak istediğiniz için bunu yapıyorsunuz.

Bir yere kopyalamak isterseniz , kopya ile almak daha mantıklıdır ve std :: 'yi const ile alıp daha sonra kopyalamak yerine dahili olarak taşıyın. Bunun nedeni, çağıranın fonksiyonunuzu çağırırken std :: shared_ptr öğesini taşıma seçeneğine izin vermenizdir, böylece kendinize bir dizi arttırma ve azaltma işlemi kaydedersiniz. Ya da değil. Yani, işlevin arayanı işlevi çağırdıktan sonra std :: shared_ptr'e ihtiyaç duyup duymadığına ve hareket edip etmemesine bağlı olarak karar verebilir. Eğer cons & 'ile geçerseniz bu gerçekleştirilemez ve dolayısıyla tercihen değere göre alınır.

Tabii ki, arayan her ikisi de onun paylaşılan_ptr'sini daha uzun süre ihtiyaç duyarsa (böylece std :: hareket edemez) ve işlevde düz bir kopya oluşturmak istemezseniz (zayıf bir işaretçi istediğinizi veya yalnızca bazen istediğinizi) kopyalamak için, bazı koşullara bağlı olarak), bir const hala tercih edilebilir.

Örneğin, yapmalısın

void enqueue(std::shared<T> t) m_internal_queue.enqueue(std::move(t));

bitmiş

void enqueue(std::shared<T> const& t) m_internal_queue.enqueue(t);

Çünkü bu durumda daima dahili olarak bir kopya oluşturursunuz.

Atomik artış ve azalışın olduğu paylaşılan_kopya kopyalama işleminin zaman maliyetini bilmeden, çok daha yüksek CPU kullanım sorunu yaşadım. Atomik artışın ve azalmanın bu kadar pahalıya mal olmasını beklemiyordum.

Test sonucumu takiben int32 atomik artış ve azalış, atomik olmayan artış ve azalıştan 2 veya 40 kat daha fazla zaman alır. Windows 8.1 ile 3GHz Core i7'de aldım. İlk sonuç çekişme olmadığında, ikincisi yüksek çekişme olasılığı ortaya çıktığında ortaya çıkar. Atomik işlemlerin sonunda donanım tabanlı kilit olduğunu aklımda tutuyorum. Kilit kilittir. Çekişme gerçekleştiğinde performans kötü.

Bunu deneyimleyerek, her zaman byval'dan (shared_ptr) byref (const shared_ptr &) kullanıyorum.

Yeni bir blog yazısı vardı: https://medium.com/@vgasparyan1995/pass-by-value-vs-pass-by-reference-to-const-c-f8944171e3ce

Bunun cevabı şudur: (neredeyse) asla geçmeyin const shared_ptr<T>&.
Bunun yerine temel sınıfı geçin.

Temel olarak sadece makul parametre türleri şunlardır:

• shared_ptr<T> - Değiştirme ve sahiplik alma
• shared_ptr<const T> - Değiştirme, sahiplik alma
• T& - Değiştir, sahiplik yok
• const T& - Değişiklik yapma, sahiplik yok
• T - Değiştirmeyin, sahiplik yok, Kopyalamak için ucuz

@Accel'in belirttiği gibi https://stackoverflow.com/a/26197326/1930508 Herb Sutter'ın tavsiyesi:

Const shared_ptr & parametresini yalnızca bir kopya alıp almayacağınızdan ve sahipliğini paylaşıp paylaşmayacağınızdan emin değilseniz parametre olarak kullanın

Ancak kaç durumda emin değilsiniz? Bu nadir bir durum

Shared_ptr değerini değere göre geçirmenin bir maliyeti olduğu ve mümkünse kaçınılması gerektiği bilinmektedir.

Shared_ptr'den geçmenin maliyeti

Çoğu zaman paylaşılan_ptr değerini başvuru ile ve hatta const referansı ile daha iyi geçerdi.

Cpp çekirdek kılavuzunun shared_ptr iletimi için belirli bir kuralı vardır

R.34: Bir işlevin parça sahibi olduğunu ifade etmek için paylaşılan_ptr parametresini alın

void share(shared_ptr<widget>);            // share -- "will" retain refcount

Paylaşılan_ptr değerini değere göre geçirmenin gerçekten gerekli bir örneği, çağıranın paylaşılan bir nesneyi eşzamansız bir çembere geçirmesi - yani çağıran işi tamamlamadan çağıranın kapsam dışına çıkmasıdır. Callee değere göre bir share_ptr değeri alarak paylaşılan nesnenin ömrünü "uzatmalıdır". Bu durumda, paylaşılan_ptr dosyasına bir başvuru iletmek işe yaramaz.

Aynı şey, paylaşılan bir nesneyi iş parçacığına geçirmek için de geçerlidir.

shared_ptr yeterince büyük değil, aynı zamanda yapıcı \ destructor, kopyadan referansa veya kopya performansa göre geçişi önemsemek için kopyadan yeterli ek yükü oluşturmak için yeterli iş yapmıyor.