class my_class { ... my_class(my_class const &) = delete; ... }; Que = deletesignifie dans ce contexte? Y a-t-il d'autres "modificateurs" (autres que = 0et = delete)?
Je suis tombé sur une proposition appelée "référence rvalue pour * this" dans la page d'état C ++ 11 de clang . J'ai beaucoup lu sur les références rvalue et les ai comprises, mais je ne pense pas que je sache cela. Je n'ai pas non plus trouvé beaucoup de …
std::unique_ptr prend en charge les tableaux, par exemple: std::unique_ptr<int[]> p(new int[10]); mais est-ce nécessaire? il est probablement plus pratique à utiliser std::vectorou std::array. Trouvez-vous une utilité pour cette construction?
J'ai trouvé une régression des performances intéressante dans un petit extrait C ++, lorsque j'active 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()); …
Les vecteurs C ++ 11 ont la nouvelle fonction emplace_back. Contrairement à push_back, qui repose sur les optimisations du compilateur pour éviter les copies, emplace_backutilise un transfert parfait pour envoyer les arguments directement au constructeur pour créer un objet sur place. Il me semble que emplace_backtout push_backpeut faire, mais parfois …
Je peux voir pourquoi le autotype en C ++ 11 améliore l'exactitude et la maintenabilité. J'ai lu que cela peut également améliorer les performances ( presque toujours automatique par Herb Sutter), mais je manque une bonne explication. Comment puis auto améliorer les performances? Quelqu'un peut-il donner un exemple?
En C ++ 11, existe-t-il un moyen de modèle d'une fonction lambda? Ou est-il intrinsèquement trop spécifique pour être modelé? Je comprends que je peux plutôt définir une classe / un foncteur de modèles classique, mais la question est plus comme: le langage autorise-t-il les modèles de fonctions lambda?
Ok, donc la dernière fois que j'ai écrit C ++ pour gagner ma vie, std::auto_ptrc'était toute la lib std disponible, et boost::shared_ptrc'était à la mode. Je n'ai jamais vraiment examiné les autres types de pointeurs intelligents fournis. Je comprends que C ++ 11 fournit maintenant certains des types de boost …
Je sais qu'au moins une des modifications de C ++ 11 qui entraînera l'arrêt de la compilation de l'ancien code: l'introduction de explicit operator bool()dans la bibliothèque standard, remplaçant les anciennes instances de operator void*(). Certes, le code que cela cassera est probablement un code qui n'aurait pas dû être …
Pour autant que je sache, l'introduction du overridemot - clé en C ++ 11 n'est rien de plus qu'une vérification pour s'assurer que la fonction en cours d'implémentation est l' overrideingénierie d'une virtualfonction dans la classe de base. Est-ce que c'est ça?
J'ai vu defaultutilisé à côté des déclarations de fonction dans une classe. Qu'est ce que ça fait? class C { C(const C&) = default; C(C&&) = default; C& operator=(const C&) & = default; C& operator=(C&&) & = default; virtual ~C() { } };
J'ai utilisé le nouveau automot clé disponible dans la norme C ++ 11 pour les types de modèles compliqués, ce pour quoi je pense qu'il a été conçu. Mais je l'utilise aussi pour des choses comme: auto foo = std::make_shared<Foo>(); Et plus sceptiquement pour: auto foo = bla(); // where …
Quel est le problème avec ce programme? #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'erreur: 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 …
Pourquoi n'y a-t-il pas de std::make_uniquemodèle de fonction dans la bibliothèque C ++ 11 standard? je trouve std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3)); un peu bavard. Les éléments suivants ne seraient-ils pas beaucoup plus agréables? auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3); Cela cache newbien et ne mentionne le type qu'une seule …
En lisant quelques exemples de boucles basées sur une plage, ils suggèrent deux façons principales 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 } …
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.