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() { } }; […]
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 […]
È 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 […]
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. […]
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 […]
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 […]
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ò […]
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; […]
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 } };
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 […]