Sabit başvuru ile bir std :: işlevini geçmeli miyim?

Diyelim ki aşağıdakileri alan bir fonksiyonum var std::function:

void callFunction(std::function<void()> x)
{
    x();
}

Bunun xyerine const-reference ile geçmeli miyim ? :

void callFunction(const std::function<void()>& x)
{
    x();
}

Bu sorunun cevabı, işlevin onunla ne yaptığına bağlı olarak değişiyor mu? Örneğin std::function, bir üye değişkeni içine saklayan veya başlatan bir sınıf üyesi işlevi veya kurucusuysa .

Performans istiyorsanız, saklıyorsanız değere göre geçin.

"Bunu UI iş parçacığında çalıştır" adında bir işleve sahip olduğunuzu varsayalım.

std::future<void> run_in_ui_thread( std::function<void()> )

"ui" iş parçacığında bazı kodlar çalıştırılır, sonra futurene zaman yapıldığına işaret eder . (UI iş parçacığının UI öğeleriyle uğraşmanız gereken yerlerde UI çerçevelerinde kullanışlıdır)

Düşündüğümüz iki imzamız var:

std::future<void> run_in_ui_thread( std::function<void()> ) // (A)
std::future<void> run_in_ui_thread( std::function<void()> const& ) // (B)

Şimdi bunları muhtemelen şu şekilde kullanacağız:

run_in_ui_thread( [=]{
  // code goes here
} ).wait();

anonim bir kapatma (lambda) oluşturacak, bir std::functiondışarı oluşturacak, run_in_ui_threadişleve geçirecek ve daha sonra ana iş parçacığında çalışmasını bitirmesini bekleyecektir.

(A) durumunda std::function, doğrudan lambdadan yapılır, daha sonra içinde kullanılır run_in_ui_thread. Lambda, moveiçine girer std::function, bu nedenle herhangi bir hareketli durum etkili bir şekilde içine taşınır.

İkinci durumda, bir geçici std::functionyaratılır, lambda moveiçine girilir , daha sonra bu geçici std::function, içinde referans olarak kullanılır run_in_ui_thread.

Şimdiye kadar, çok iyi - ikisi aynı performans gösteriyor. Dışında run_in_ui_threadişlevi argüman bir kopyasını yapacak yürütmek için ui iplik göndermek için! (onunla yapılmadan önce geri dönecektir, bu yüzden sadece bir referans kullanamaz). Durumda, (A) için, basitçe uzun vadeli depoya. (B) durumunda, kopyalamak zorunda kalırız .movestd::functionstd::function

Bu mağaza, değere göre geçişi daha uygun hale getirir. Bir kopyasını saklamak için herhangi bir olasılık varsa, std::functiondeğere göre geçin. Aksi takdirde, her iki yol da kabaca eşdeğerdir: by-value için tek dezavantaj, aynı hantal std::functionalıp başka bir kullanımdan sonra bir alt yönteme sahip olmanızdır . Bunu engellemek, a movekadar etkili olacaktır const&.

Şimdi, ikisinin arasında, içinde kalıcı bir durumumuz varsa çoğunlukla devreye giren başka bazı farklılıklar var std::function.

std::functionBir nesneyi a ile sakladığını operator() const, ancak mutabledeğiştirdiği (ne kadar kaba!) Bazı veri üyelerine sahip olduğunu varsayın .

Bu std::function<> const&durumda, mutabledeğiştirilen veri üyeleri işlev çağrısından yayılır. In std::function<>durumunda, bunlar olmaz.

Bu nispeten garip bir köşe davası.

std::functionMuhtemelen ağır, ucuza hareket eden başka bir şeymiş gibi davranmak istersiniz. Taşınma ucuz, kopyalama pahalı olabilir.

Performans konusunda endişeleniyorsanız ve bir sanal üye işlevi tanımlamıyorsanız, büyük olasılıkla hiç kullanmamalısınız std::function.

Functor türünü şablon parametresi yapmak, std::functionfunctor mantığını satır içine almak da dahil olmak üzere daha fazla optimizasyon sağlar . Bu optimizasyonların etkisinin, nasıl geçileceğine ilişkin kopyalama-dolaylı kaygılarından büyük ölçüde ağır basması muhtemeldir std::function.

Daha hızlı:

template<typename Functor>
void callFunction(Functor&& x)
{
    x();
}

C ++ 11'de her zamanki gibi, value / reference / const-reference'den geçmek argümanınızla ne yaptığınıza bağlıdır. std::functionfarklı değil.

Değere göre iletme , bağımsız değişkeni bir değişkene (genellikle bir sınıfın üye değişkeni) taşımanıza olanak tanır:

struct Foo {
    Foo(Object o) : m_o(std::move(o)) {}

    Object m_o;
};

İşlevinizin argümanını taşıyacağını bildiğinizde, bu en iyi çözümdür, bu şekilde kullanıcılarınız işlevinizi nasıl çağırdıklarını kontrol edebilir:

Foo f1{Object()};               // move the temporary, followed by a move in the constructor
Foo f2{some_object};            // copy the object, followed by a move in the constructor
Foo f3{std::move(some_object)}; // move the object, followed by a move in the constructor

Ben zaten const referanslarının (anlamsız) anlamlarını bildiğinize inanıyorum, bu yüzden konuyu işaretlemeyeceğim. Bununla ilgili daha fazla açıklama eklemem gerekiyorsa, sormanız yeterlidir.