In c ++ 14 viene introdotto l’idioma decltype(auto) . Tipicamente il suo uso è quello di consentire alle dichiarazioni auto di utilizzare le regole decltype sull’espressione data . Cercando esempi di utilizzo “buono” dell’idioma, posso solo pensare a cose come la seguente (di Scott Meyers ), vale a dire per la deduzione di tipo restituito […]
Se inizializzo uno std :: array come segue, il compilatore mi avvisa delle parentesi mancanti std::array a = {1, 2, 3, 4}; Questo risolve il problema: std::array a = {{1, 2, 3, 4}}; Questo è il messaggio di avviso: missing braces around initializer for ‘std::array::value_type [4] {aka int [4]}’ [-Wmissing-braces] È solo un bug nella […]
Il mio compilatore non supporta make_unique. Come scriverne uno? template unique_ptr make_unique( Args&&… args );
Prima del C ++ 11 ho usato boost::bind o boost::lambda molto. La parte di bind è stata inserita nella libreria standard ( std::bind ), mentre l’altra parte è diventata parte del linguaggio principale (lambda C ++) e ha reso l’uso di lambda molto più semplice. Al giorno d’oggi, non uso std::bind , dal momento che […]
template struct Hitchhiker { static_assert(sizeof(answer) != sizeof(answer), “Invalid answer”); }; template struct Hitchhiker {}; Durante il tentativo di disabilitare l’istanza di template generale con static_assert ho scoperto che il codice sopra in clang genera l’errore di asserzione anche quando il modello non è istanziato, mentre gcc genera l’errore di asserzione solo quando si esegue l’istanziazione […]
Background: Ho creato la seguente class C , il cui costruttore dovrebbe prendere N variabili di tipo B& : class A; class B { A* getA(); }; template class C { public: template inline C(Args&… args) : member{args.getA()…} {} private: std::array member; }; Problema: il mio problema è come limitare gli Arg variadici a essere […]
Come funziona il lambda generico (parola chiave auto come tipo di argomento) nello standard C ++ 14? Si basa su modelli C ++ in cui per ogni tipo di argomento diverso il compilatore genera una nuova funzione con lo stesso corpo ma tipi sostituiti (polimorfismo in fase di compilazione) o è più simile ai generici […]
gcc 4.9 consente il seguente codice, ma gcc 4.8 e clang 3.5.0 lo rifiutano. void foo(auto c) { std::cout << c.c_str(); } Ricevo un warning: ISO C++ forbids use of ‘auto’ in parameter declaration [-Wpedantic] in 4.9 ma in 4.8 e clang ottengo error: parameter declared ‘auto’ .
std::make_unique ha vantaggi di efficienza come std::makes_shared ? Rispetto alla costruzione manuale di std::unique_ptr : std::make_unique(1); // vs std::unique_ptr(new int(1));
È consentito in standard: struct A { int a = 3; int b = 3; }; A a{0,1}; // ??? Questa class è ancora aggregata? clang accetta questo codice, ma gcc no.