Ci sono risorse su come identificare i problemi che potrebbero essere meglio risolti con i modelli?

Libri:

Design C ++ moderno

C ++ Template Metaprogramming

Avere familiarità con la ricorsione e la programmazione funzionale è un vantaggio enorme, poiché questo è ciò che comporta molto tmp. È completo e quindi praticamente tutto è possibile, anche se di solito si riduce ad applicare funzioni pure a costanti o generare tipi da altri tipi.

Attenzione: il tmp è un brutto mostro che trasforma un bel codice in spaghetti. Più lo usi e meno ti piacerà il C ++. È una cosa cattiva.

Scopri Haskell o qualche altro linguaggio puramente funzionale (Lisp, Scheme, OCaml per nominarne alcuni, puoi trovare altro su Wikipedia ).

Considerando Haskell, puoi trovare ulteriori informazioni sulle strutture di metaprogrammazione qui .

La programmazione dei modelli segue praticamente le stesse regole.

Solo perché puoi fare qualcosa con i modelli non significa che dovresti. In pratica, a meno che quando stai progettando pensi che questo sia un lavoro fantastico per i modelli, è probabilmente meglio non usarli. se pensi troppo ai modelli, crei un codice follemente astratto che è altrettanto brutto di una singola funzione gigante.

Tieni presente che i modelli rappresentano la soluzione migliore è molto raro. Ho definito la mia solo una volta negli ultimi 5 anni, ei miei colleghi che hanno revisionato quel codice non l'avevano mai fatto. I casi in cui i modelli hanno molto senso sono stati in gran parte già implementati nelle librerie standard.

Per la programmazione generica, la cosa da tenere a mente è che stai copiando e incollando le funzioni per apportare solo piccole modifiche, come costanti o tipi, e non riesci a trovare un modo pulito per usare qualcosa come l'ereditarietà oi parametri di funzione per evitare di ripetere te stesso.

Un modello abbastanza comune è usato per i tipi di sicurezza, se hai tipi che si comportano allo stesso modo, ma per qualsiasi motivo non li vuoi confondere casualmente.

Per il calcolo del tempo di compilazione utilizzando i modelli, la cosa da tenere a mente è un calcolo intensivo delle risorse in cui tutti i suoi input sono noti al momento della compilazione, ma dove diversi input costanti vengono utilizzati in diversi punti del codice. Tuttavia, tieni presente che questo rallenterà le tue compilazioni ogni volta, quindi spesso è preferibile inserire manualmente i risultati con codice univoco, se non cambiano molto spesso.

Alcuni sostenitori utilizzano modelli per micro-ottimizzazioni come evitare le ricerche di tabelle virtuali usando il polimorfismo statico o per lo srotolamento del ciclo, ma a mio parere la complessità di solito supera i guadagni in termini di prestazioni a meno che il codice sia molto critico per le prestazioni.

Fondamentalmente, ci sono diversi buoni motivi per usare i template:

1. Hai una funzione o una classe che ha la stessa funzionalità per diversi tipi. Un buon esempio di utilizzo di buoni modelli è la libreria di potenziamento
2. desideri utilizzare il polimorfismo statico e ottenere errori di compilazione, anziché errori di run-time
3. si desidera ottenere un comportamento specifico in base ad alcuni parametri statici. Ad esempio, boost :: type_traits fornisce molto bene esempi.

Dovresti assolutamente cercare nei template in C ++! Ciò ti aiuterà molto a capire argomenti come Design Patterns e Programmazione generica. Confrontali con ciò che altre lingue ti offrono. In modo preciso dovresti usare i template in particolare nei seguenti scenari:

1. Generalizzazione & Riutilizzo del codice
2. Flessibilità
3. Tempo e amp; Vincoli di budget
4. Mancanza di esperienza per un determinato compito

Ecco una buona risorsa online per te: link

Un semplice indicatore di quando un modello dovrebbe migliorare il tuo codice, è quando vedi che il tuo codice richiede spesso di lanciare un oggetto su un tipo diverso. Un esempio che ho trovato nel mio codice Java, che mi ha indotto a convertire una firma di metodo esistente in un modello:

    public MsgBase getLastSentMessage(Class<? extends MsgBase> msgBaseClass)

Il mio codice cliente ha sempre avuto questo aspetto:

    OrderResponse response = (OrderResponse) getLastSentMessage(OrderResponse.class);

e ogni volta che ho usato quel metodo, ho dovuto trasmettere il risultato alla sottoclasse corretta del tipo MsgBase. La firma del metodo migliorata era:

    public <T extends MsgBase> T getLastSentMessage(Class<T> clazz)

Ora il codice cliente era:

     OrderResponse response = getLastSentMessage(OrderResponse.class);

Quindi, per riassumere, se ti trovi a fare un sacco di casting che sembra non necessario, potresti avere un buon caso in cui un modello pulirà il tuo codice.

Aggiornamento: un modo migliore per generalizzare l'affermazione precedente:

When your source class will be used by objects of many different types, and the source class can interact with those types at a higher (more abstract) level, but your client classes want to interact with specific subtypes, that is a case for using templates. (Container/List classes being the well-known example).

Proprio oggi, ho usato i modelli per implementare una macchina a stati finiti per un po 'di input. I modelli di espressione sono strumenti estremamente potenti per implementare concetti di codice come questo: funzionano come C ++ ottimizzati a mano e sono oscenamente veloci, ma molto generici e molto facili da scrivere.

In generale, i modelli hanno più senso quando si implementano algoritmi generici. Se non stai implementando un algoritmo generico, non ha molto senso.

Gli usi più comuni dei modelli sono i seguenti:

std::vector<int> vec;
std::map<int, float> mymap;

Quindi il prossimo esempio comune è:

template<class T>
class MyArray {
public:
   virtual T get(int i) const=0;
};

Insieme a questo tipo di utilizzo:

class ArrayImpl : public MyArray<float> {
public:
     float get(int i) const { }
};

Quella mostrava una parte importante dei modelli, che è la sostituzione di tipo - T è rimpiazzata con il tipo float in entrambe le posizioni in cui è usata.