class my_class { ... my_class(my_class const &) = delete; ... }; Cosa = deletesignifica in quel contesto? Ci sono altri "modificatori" (diversi da = 0e = delete)?
Ho trovato una proposta chiamata "riferimento al valore per * this" nella pagina di stato C ++ 11 di clang . Ho letto un bel po 'di riferimenti a valori e li ho compresi, ma non credo di saperlo. Inoltre non sono riuscito a trovare molte risorse sul web usando …
std::unique_ptr supporta gli array, ad esempio: std::unique_ptr<int[]> p(new int[10]); ma è necessario? probabilmente è più comodo da usare std::vectoro std::array. Trovi utile per quel costrutto?
Ho trovato un'interessante regressione delle prestazioni in un piccolo frammento di C ++, quando abilito C ++ 11: #include <vector> struct Item { int a; int b; }; int main() { const std::size_t num_items = 10000000; std::vector<Item> container; container.reserve(num_items); for (std::size_t i = 0; i < num_items; ++i) { container.push_back(Item()); …
I vettori C ++ 11 hanno la nuova funzione emplace_back. Diversamente push_back, che si basa sulle ottimizzazioni del compilatore per evitare copie, emplace_backutilizza l'inoltro perfetto per inviare gli argomenti direttamente al costruttore per creare un oggetto sul posto. Mi sembra che emplace_backfa tutto ciò che push_backpuò fare, ma qualche volta …
Posso capire perché il autotipo in C ++ 11 migliora la correttezza e la manutenibilità. Ho letto che può anche migliorare le prestazioni ( Almost Always Auto di Herb Sutter), ma mi manca una buona spiegazione. Come può automigliorare le prestazioni? Qualcuno può fare un esempio?
In C ++ 11, c'è un modo per modellare una funzione lambda? O è intrinsecamente troppo specifico per essere modellato? Capisco che posso invece definire una classica classe / funzione basata su modelli, ma la domanda è più simile: il linguaggio consente le funzioni lambda di modello?
Ok, quindi l'ultima volta che ho scritto C ++ per vivere, std::auto_ptrc'era tutta la lib standard disponibile ed boost::shared_ptrera di gran moda. Non ho mai veramente esaminato gli altri tipi di puntatori intelligenti forniti. Comprendo che C ++ 11 ora fornisce alcuni dei tipi di boost creati, ma non tutti. …
So che almeno una delle modifiche in C ++ 11 che causerà l'interruzione della compilazione di alcuni vecchi codici: l'introduzione di explicit operator bool() nella libreria standard, in sostituzione di vecchie istanze di operator void*(). Certo, il codice che questo si romperà è probabilmente un codice che non avrebbe dovuto …
Per quanto ho capito, l'introduzione della overrideparola chiave in C ++ 11 non è altro che un controllo per assicurarsi che la funzione implementata sia l' overrideing di una virtualfunzione nella classe base. È così?
Ho visto defaultusato accanto alle dichiarazioni di funzioni in una classe. Che cosa fa? class C { C(const C&) = default; C(C&&) = default; C& operator=(const C&) & = default; C& operator=(C&&) & = default; virtual ~C() { } };
Sto usando la nuova autoparola chiave disponibile nello standard C ++ 11 per i tipi complicati di modelli, che è ciò per cui credo sia stato progettato. Ma lo sto usando anche per cose come: auto foo = std::make_shared<Foo>(); E più scettico per: auto foo = bla(); // where bla() …
Cosa c'è di sbagliato in questo programma? #include <memory> #include <vector> int main() { std::vector<std::unique_ptr<int>> vec; int x(1); std::unique_ptr<int> ptr2x(&x); vec.push_back(ptr2x); //This tiny command has a vicious error. return 0; } L'errore: In file included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/mingw32/bits/c++allocator.h:34:0, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/allocator.h:48, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/memory:64, from main.cpp:6: c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function 'void __gnu_cxx::new_allocator<_Tp>::construct(_Tp*, const …
Perché non esiste un std::make_uniquemodello di funzione nella libreria C ++ 11 standard? io trovo std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3)); un po 'prolisso. Quanto segue non sarebbe molto più bello? auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3); Questo nasconde newbene e menziona il tipo solo una volta. Ad ogni modo, ecco …
Leggendo alcuni esempi di loop basati su range, suggeriscono due modi principali 1 , 2 , 3 , 4 std::vector<MyClass> vec; for (auto &x : vec) { // x is a reference to an item of vec // We can change vec's items by changing x } o for (auto …
We use cookies and other tracking technologies to improve your browsing experience on our website,
to show you personalized content and targeted ads, to analyze our website traffic,
and to understand where our visitors are coming from.
By continuing, you consent to our use of cookies and other tracking technologies and
affirm you're at least 16 years old or have consent from a parent or guardian.