Dovrei usare std :: function o un puntatore a funzione in C ++?

Quando implemento una funzione di callback in C ++, dovrei ancora usare il puntatore alla funzione in stile C:

void (*callbackFunc)(int);

O dovrei usare std :: function:

std::function< void(int) > callbackFunc;

In breve, usa astd::function meno che tu non abbia un motivo per non farlo.

I puntatori a funzione hanno lo svantaggio di non essere in grado di acquisire alcuni contesti. Ad esempio, non sarà possibile passare una funzione lambda come callback che acquisisce alcune variabili di contesto (ma funzionerà se non ne acquisisce nessuna). Anche la chiamata di una variabile membro di un oggetto (cioè non statica) non è quindi possibile, poiché l'oggetto ( this-punto) deve essere catturato. ⁽¹⁾

std::function(dal momento che C ++ 11) è principalmente quello di memorizzare una funzione (passarla in giro non richiede che sia memorizzata). Pertanto, se si desidera archiviare il callback, ad esempio in una variabile membro, è probabilmente la scelta migliore. Ma anche se non lo memorizzi, è una buona "prima scelta" anche se ha lo svantaggio di introdurre un overhead (molto piccolo) quando viene chiamato (quindi in una situazione molto critica delle prestazioni potrebbe essere un problema ma nella maggior parte non dovrebbe). È molto "universale": se ti preoccupi molto del codice coerente e leggibile e non vuoi pensare a ogni scelta che fai (cioè vuoi mantenerlo semplice), usa std::functionper ogni funzione che passi.

Pensa a una terza opzione: se stai per implementare una piccola funzione che poi segnala qualcosa tramite la funzione di callback fornita, considera un parametro modello , che può quindi essere qualsiasi oggetto richiamabile , ad esempio un puntatore a funzione, un funzione, un lambda, a std::function, ... Lo svantaggio è che la tua funzione (esterna) diventa un modello e quindi deve essere implementata nell'intestazione. D'altra parte, si ottiene il vantaggio che la chiamata al callback può essere incorporata, poiché il codice client della funzione (esterna) "vede" la chiamata al callback con le informazioni esatte sul tipo disponibili.

Esempio per la versione con il parametro template (scrivere &invece che &&per pre-C ++ 11):

template <typename CallbackFunction>
void myFunction(..., CallbackFunction && callback) {
    ...
    callback(...);
    ...
}

Come puoi vedere nella tabella seguente, tutti hanno i loro vantaggi e svantaggi:

+-------------------+--------------+---------------+----------------+
|                   | 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) Esistono soluzioni alternative per superare questa limitazione, ad esempio passando i dati aggiuntivi come ulteriori parametri alla funzione (esterna): myFunction(..., callback, data)chiamerà callback(data). Questo è il "callback con argomenti" in stile C, che è possibile in C ++ (e comunque ampiamente utilizzato nell'API WIN32) ma dovrebbe essere evitato perché abbiamo opzioni migliori in C ++.}

_{(2) A meno che non stiamo parlando di un modello di classe, ovvero la classe in cui memorizzi la funzione è un modello. Ciò significherebbe che sul lato client il tipo di funzione decide il tipo di oggetto che memorizza il callback, che non è quasi mai un'opzione per i casi d'uso reali.}

_{(3) Per pre-C ++ 11, utilizzare boost::function}

void (*callbackFunc)(int); può essere una funzione di callback in stile C, ma è orribilmente inutilizzabile con un design scadente.

Sembra un callback in stile C ben progettato void (*callbackFunc)(void*, int);: deve void*consentire al codice che esegue il callback di mantenere lo stato oltre la funzione. Non farlo costringe il chiamante a memorizzare lo stato a livello globale, il che è scortese.

std::function< int(int) >finisce per essere leggermente più costoso int(*)(void*, int)dell'invocazione nella maggior parte delle implementazioni. Tuttavia, per alcuni compilatori è più difficile inline. Esistono std::functionimplementazioni di cloni che rivaleggiano con le spese generali di invocazione dei puntatori di funzione (vedere "delegati più veloci possibili", ecc.) Che possono entrare nelle librerie.

Ora, i client di un sistema di callback devono spesso impostare risorse e smaltirle quando il callback viene creato e rimosso e essere consapevoli della durata del callback. void(*callback)(void*, int)non fornisce questo.

A volte questo è disponibile tramite la struttura del codice (il callback ha una durata limitata) o tramite altri meccanismi (annulla la registrazione di callback e simili).

std::function fornisce un mezzo per la gestione a vita limitata (l'ultima copia dell'oggetto scompare quando viene dimenticata).

In generale, userei un std::functionmanifest a meno che non riguardi le prestazioni. Se lo facessero, cercherei prima i cambiamenti strutturali (invece di un callback per pixel, che ne dici di generare un processore scanline basato sul lambda che mi passi? Che dovrebbe essere sufficiente per ridurre l'overhead della chiamata di funzione a livelli banali. ). Quindi, se persiste, scrivo un delegatedelegato basato sul più veloce possibile e vedo se il problema delle prestazioni scompare.

Utilizzerei principalmente i puntatori a funzione per API legacy o per la creazione di interfacce C per la comunicazione tra codice generato da diversi compilatori. Li ho anche usati come dettagli di implementazione interni quando sto implementando tabelle di salto, tipo di cancellazione, ecc: quando lo sto producendo e consumando, e non lo sto esponendo esternamente per l'uso di qualsiasi codice client, e i puntatori a funzione fanno tutto ciò di cui ho bisogno .

Si noti che è possibile scrivere wrapper che trasformano a std::function<int(int)>in uno int(void*,int)stile di callback, supponendo che vi sia una corretta infrastruttura di gestione della durata del callback. Quindi, come test del fumo per qualsiasi sistema di gestione della durata della richiamata in stile C, mi assicurerei che il confezionamento funzioni std::functionragionevolmente bene.

Utilizzare std::functionper memorizzare oggetti richiamabili arbitrari. Consente all'utente di fornire qualunque contesto sia necessario per la richiamata; un semplice puntatore a funzione no.

Se hai bisogno di usare semplici puntatori a funzioni per qualche motivo (forse perché vuoi un'API compatibile con C), allora dovresti aggiungere un void * user_contextargomento in modo che sia almeno possibile (anche se scomodo) che acceda allo stato che non è passato direttamente al funzione.

L'unico motivo per evitare std::functionè il supporto di compilatori legacy che non supportano questo modello, che è stato introdotto in C ++ 11.

Se il supporto del linguaggio pre-C ++ 11 non è un requisito, l'utilizzo std::functionoffre ai chiamanti una scelta più ampia nell'implementazione del callback, rendendolo un'opzione migliore rispetto ai puntatori di funzione "semplici". Offre agli utenti della tua API una scelta più ampia, mentre astrarre le specifiche della loro implementazione per il tuo codice che esegue il callback.

std::function può portare VMT nel codice in alcuni casi, il che ha un impatto sulle prestazioni.