Articles of templates

Il pacchetto di parametri deve essere alla fine dell’elenco dei parametri … Quando e perché?

Non capisco il motivo per cui un pacchetto di parametri deve essere alla fine dell’elenco dei parametri se quest’ultimo è associato a una class, mentre il vincolo è rilassato se l’elenco dei parametri è parte di una dichiarazione del metodo membro. In altri termini, questo compila: class C { template void fn() { } }; […]

Modelli C ++ per le prestazioni?

Ho visto online alcune volte che è stato detto che C ++ può essere sempre più veloce usando i template. Qualcuno potrebbe spiegare, anche a un livello basso perché questo è esattamente? Ho sempre pensato che una caratteristica così “carina” avrebbe avuto un sovraccarico come la maggior parte dei concetti utili. Sono davvero incuriosito da […]

QT: class Q_OBJECT Templated

È ansible avere una class template, che eredita da QObject (e ha macro Q_OBJECT nella sua dichiarazione)? Mi piacerebbe creare qualcosa come adattatore per slot, che farebbe qualcosa, ma lo slot può assumere un numero arbitrario di argomenti (il numero di argomenti dipende dall’argomento del template). Ho appena provato a farlo e ho avuto errori […]

Combinare le risorse assetiche tra i modelli ereditati

Stiamo costruendo un nuovo sito con Symfony2 e Assetic sembra molto promettente per la gestione delle risorse, in particolare per combinare e processare tutti i file js / css automaticamente. Avremo alcune risorse utilizzate in tutto il sito e alcune specifiche per pagine specifiche. Useremo anche un approccio ereditato a tre livelli per i modelli. […]

Conversione implicita quando si sovraccaricano gli operatori per le classi template

Vorrei sapere perché la conversione di tipo implicita non funziona con il sovraccarico dell’operatore esterno sui modelli di class. Ecco la versione funzionante e non-templata: class foo { public: foo() = default; foo(int that) {} foo& operator +=(foo rhs) { return *this; } }; foo operator +(foo lhs, foo rhs) { lhs += rhs; return […]

dichiarazione di amicizia dichiara una funzione non modello

Ho una class base simile al codice qui sotto. Sto tentando di sovraccaricare << da usare con cout. Tuttavia, g ++ sta dicendo: base.h:24: warning: friend declaration ‘std::ostream& operator<<(std::ostream&, Base*)’ declares a non-template function base.h:24: warning: (if this is not what you intended, make sure the function template has already been declared and add after […]

Perché la parola chiave “typename” è necessaria prima dei nomi dipendenti qualificati e non prima dei nomi indipendenti qualificati?

class A { static int iterator; class iterator { […] }; […] }; Io (penso io) capisco il motivo per cui typename è necessario qui: template void foo() { typename T::iterator* iter; […] } ma non capisco il motivo per cui typename non è necessario qui: void foo() { A::iterator* iter; […] } Qualcuno può […]

La funzione template C ++ compila nell’intestazione ma non nell’implementazione

Sto cercando di imparare i modelli e mi sono imbattuto in questo errore di confusione. Sto dichiarando alcune funzioni in un file di intestazione e voglio creare un file di implementazione separato in cui verranno definite le funzioni. Ecco il codice che chiama l’intestazione (dum.cpp): #include #include #include #include “dumper2.h” int main() { std::vector v; […]

Modello tupla – chiama una funzione su ciascun elemento

La mia domanda è nel codice: template struct TupleOfVectors { std::tuple<std::vector…> tuple; void do_something_to_each_vec() { //Question: I want to do this: // “for each (N)”: do_something_to_vec() //How? } template void do_something_to_vec() { auto &vec = std::get(tuple); //do something to vec } };

std :: enable_if: parametro parametro vs modello

Sto costruendo alcuni controlli di input che devono avere funzioni specifiche per interi e / o double (per esempio ‘isPrime’ dovrebbe essere disponibile solo per interi). Se sto usando enable_if come parametro funziona perfettamente: template class check { public: template inline static U readVal(typename std::enable_if<std::is_same::value >::type* = 0) { return BuffCheck.getInt(); } template inline static […]