Kısacası,std::function bir nedeniniz olmadığı sürece kullanın .
İşlev işaretçileri bazı bağlamları yakalayamama dezavantajına sahiptir . Örneğin, bazı bağlam değişkenlerini yakalayan bir geri arama olarak lambda işlevini geçiremezsiniz (ancak yakalamadığında işe yarayacaktır). Bu nedenle, bir nesnenin üye değişkenini (yani statik olmayan) thisçağırmak da mümkün değildir, çünkü nesnenin ( -pointer) yakalanması gerekir. (1)
std::function(çünkü C ++ 11) öncelikle bir işlevi saklamak içindir (onu aktarmak, saklanmasını gerektirmez). Dolayısıyla, geri aramayı örneğin bir üye değişkeninde saklamak istiyorsanız, muhtemelen en iyi seçimdir. Ama aynı zamanda saklamıyorsanız, iyi bir "ilk seçim" olmasına rağmen, çağrıldığında bazı (çok küçük) ek yükü dezavantajına sahip olsa da (çok performans açısından kritik bir durumda bir sorun olabilir, ancak çoğu olmamalıdır). Çok "evrensel": tutarlı ve okunabilir kodlara çok önem veriyorsanız ve yaptığınız her seçimi (yani basit tutmak istiyorsanız) düşünmek istemiyorsanız, std::functionetrafta dolaştığınız her fonksiyon için kullanın .
Üçüncü bir seçenek düşünün: o zaman sağlanan geri arama fonksiyonu vasıtasıyla şey bildiriyor küçük işlevi uygulamak için yaklaşık iseniz, bir düşünün şablon parametresi sonra olabilir, herhangi bir çağrılabilir nesne , yani bir işlev işaretçisi, bir funktoru, bir lambda, a std::function, ... Buradaki dezavantaj, (dış) işlevinizin bir şablon haline gelmesi ve dolayısıyla başlıkta uygulanması gerektiğidir. Öte yandan, (dış) fonksiyonunuzun istemci kodu, geri çağrıya yapılan çağrının tam olarak kullanılabilecek tür bilgisi olacağını "gördüğü" için, geri çağrıya yapılan çağrının satır içine alınabilmesi avantajını elde edersiniz.
Template parametresine sahip sürüm örneği ( C ++ 11 öncesi &yerine yazma &&):
template <typename CallbackFunction>
void myFunction(..., CallbackFunction && callback) {
...
callback(...);
...
}
Aşağıdaki tabloda görebileceğiniz gibi, hepsinin avantajları ve dezavantajları vardır:
+-------------------+--------------+---------------+----------------+
| | function ptr | std::function | template param |
+===================+==============+===============+================+
| can capture | no(1) | yes | yes |
| context variables | | | |
+-------------------+--------------+---------------+----------------+
| no call overhead | yes | no | yes |
| (see comments) | | | |
+-------------------+--------------+---------------+----------------+
| can be inlined | no | no | yes |
| (see comments) | | | |
+-------------------+--------------+---------------+----------------+
| can be stored | yes | yes | no(2) |
| in class member | | | |
+-------------------+--------------+---------------+----------------+
| can be implemented| yes | yes | no |
| outside of header | | | |
+-------------------+--------------+---------------+----------------+
| supported without | yes | no(3) | yes |
| C++11 standard | | | |
+-------------------+--------------+---------------+----------------+
| nicely readable | no | yes | (yes) |
| (my opinion) | (ugly type) | | |
+-------------------+--------------+---------------+----------------+
(1) Bu sınırlamanın üstesinden gelmek için geçici çözümler mevcuttur, örneğin ek verileri (dış) fonksiyonunuza başka parametreler olarak iletmek: myFunction(..., callback, data)çağrılacaktır callback(data). C ++ 'da (ve bu arada WIN32 API'de yoğun bir şekilde kullanılırken) mümkün olan ancak C ++' da daha iyi seçeneklere sahip olduğumuzdan kaçınılması gereken C tarzı "argümanlarla geri çağrı".
(2) Bir sınıf şablonundan bahsetmediğimiz sürece, yani işlevi sakladığınız sınıf bir şablondur. Ancak bu, istemci tarafında, işlevin türünün, gerçek kullanım durumları için neredeyse hiçbir zaman bir seçenek olmayan geri çağrıyı depolayan nesnenin türüne karar verdiği anlamına gelir.
(3) C ++ 11 öncesi için boost::function