Quels idiomes C ++ sont obsolètes dans C ++ 11?

Avec la nouvelle norme, il existe de nouvelles façons de faire les choses, et beaucoup sont plus agréables que les anciennes méthodes, mais l'ancienne méthode est toujours bonne. Il est également clair que la nouvelle norme n'est pas officiellement obsolète, pour des raisons de compatibilité descendante. La question qui reste est donc:

Quelles anciennes méthodes de codage sont définitivement inférieures aux styles C ++ 11, et que pouvons-nous faire maintenant à la place?

En répondant à cela, vous pouvez sauter les choses évidentes comme "utiliser des variables automatiques".

1. Classe finale : C ++ 11 fournit le finalspécificateur pour empêcher la dérivation de classe
2. Les lambdas C ++ 11 réduisent considérablement le besoin de classes d'objets de fonction nommés (foncteurs).
3. Move Constructor : les façons magiques dont les std::auto_ptrtravaux ne sont plus nécessaires en raison du support de première classe des références rvalue.
4. Safe bool : cela a été mentionné plus tôt. Les opérateurs explicites de C ++ 11 évitent cet idiome très courant de C ++ 03.
5. Réduire à l'ajustement : de nombreux conteneurs C ++ 11 STL fournissent une shrink_to_fit()fonction membre, ce qui devrait éliminer le besoin d'échanger avec un fichier temporaire.
6. Classe de base temporaire : certaines anciennes bibliothèques C ++ utilisent cet idiome plutôt complexe. Avec la sémantique de déplacement, ce n'est plus nécessaire.
7. Les énumérations de type Safe Enum sont très sûres dans C ++ 11.
8. Interdire l'allocation de tas : la = deletesyntaxe est une manière beaucoup plus directe de dire qu'une fonctionnalité particulière est explicitement refusée. Ceci est applicable pour empêcher l'allocation de tas (c'est-à-dire =deletepour le membre operator new), empêcher les copies, l'affectation, etc.
9. Typedef basé sur un modèle : modèles Alias en C ++ 11 réduire la nécessité d'typedefs de simples basé sur un modèle. Cependant, les générateurs de types complexes ont toujours besoin de méta-fonctions.
10. Certains calculs numériques au moment de la compilation, tels que Fibonacci, peuvent être facilement remplacés à l'aide d' expressions constantes généralisées
11. result_of: Les utilisations du modèle de classe result_ofdoivent être remplacées par decltype. Je pense result_ofutilise decltypequand il est disponible.
12. Les initialiseurs de membres en classe enregistrent la saisie pour l'initialisation par défaut des membres non statiques avec des valeurs par défaut.
13. Dans le nouveau C ++ 11, le code NULLdevrait être redéfini comme nullptr, mais voyez le discours de STL pour savoir pourquoi ils ont décidé de ne pas le faire.
14. Les fanatiques de modèles d'expression sont ravis d'avoir la syntaxe de la fonction de type retour de fin en C ++ 11. Fini les types de retour de 30 lignes!

Je pense que je vais m'arrêter là!

À un moment donné, on a fait valoir qu'il fallait renvoyer par constvaleur au lieu de simplement par valeur:

const A foo();
^^^^^

C'était pour la plupart inoffensif en C ++ 98/03, et peut même avoir détecté quelques bogues qui ressemblaient à:

foo() = a;

Mais le retour par constest contre-indiqué en C ++ 11 car il inhibe la sémantique de déplacement:

A a = foo();  // foo will copy into a instead of move into it

Alors détendez-vous et codez:

A foo();  // return by non-const value

Dès que vous pouvez abandonner 0et NULLen faveur de nullptr, faites-le!

Dans le code non générique, l'utilisation de 0ou NULLn'est pas si grave. Mais dès que vous commencez à transmettre des constantes de pointeur nulles dans du code générique, la situation change rapidement. Lorsque vous passez 0à a, il template<class T> func(T) Test déduit comme un intet non comme une constante de pointeur nul. Et il ne peut pas être reconverti en une constante de pointeur nul après cela. Cela tombe en cascade dans un bourbier de problèmes qui n'existent tout simplement pas si l'univers est utilisé uniquement nullptr.

C ++ 11 n'est pas obsolète 0et en NULLtant que constantes de pointeur nul. Mais vous devez coder comme si c'était le cas.

Idiome booléen sûr → explicit operator bool().

Constructeurs de copie privée (boost :: noncopyable) → X(const X&) = delete

Simulation de la classe finale avec destructeur privé et héritage virtuel →class X final

L'une des choses qui vous évite d'écrire des algorithmes de base en C ++ 11 est la disponibilité des lambdas en combinaison avec les algorithmes fournis par la bibliothèque standard.

J'utilise ceux-ci maintenant et c'est incroyable à quelle fréquence vous dites simplement ce que vous voulez faire en utilisant count_if (), for_each () ou d'autres algorithmes au lieu d'avoir à réécrire les foutues boucles.

Une fois que vous utilisez un compilateur C ++ 11 avec une bibliothèque standard C ++ 11 complète, vous n'avez plus de bonne excuse pour ne pas utiliser d'algorithmes standard pour construire le vôtre . Lambda juste le tuer.

Pourquoi?

En pratique (après avoir moi-même utilisé cette façon d'écrire des algorithmes), il semble beaucoup plus facile de lire quelque chose qui est construit avec des mots simples signifiant ce qui est fait qu'avec des boucles qu'il faut déchiffrer pour en connaître le sens. Cela dit, faire déduire automatiquement des arguments lambda aiderait beaucoup à rendre la syntaxe plus facilement comparable à une boucle brute.

Fondamentalement, la lecture d'algorithmes réalisés avec des algorithmes standard est beaucoup plus facile car les mots masquent les détails d'implémentation des boucles.

Je suppose que seuls les algorithmes de niveau supérieur doivent être considérés maintenant que nous avons des algorithmes de niveau inférieur sur lesquels nous appuyer.

Vous devrez implémenter des versions personnalisées swapmoins souvent. En C ++ 03, un non-throwing efficace swapest souvent nécessaire pour éviter des copies coûteuses et lancées, et comme std::swaputilise deux copies, swapil doit souvent être personnalisé. En C ++, std::swaputilisemove , et donc l'accent est mis sur l'implémentation de constructeurs de déplacement et d'opérateurs d'affectation de déplacement efficaces et non lanceurs. Comme pour ceux-ci, la valeur par défaut est souvent très bien, ce sera beaucoup moins de travail qu'en C ++ 03.

En général, il est difficile de prédire quels idiomes seront utilisés car ils sont créés par l'expérience. On peut s'attendre à un «C ++ 11 efficace» peut-être l'année prochaine, et à des «normes de codage C ++ 11» seulement dans trois ans car l'expérience nécessaire n'est pas encore là.

Je ne connais pas le nom, mais le code C ++ 03 utilisait souvent la construction suivante en remplacement de l'affectation de déplacement manquante:

std::map<Big, Bigger> createBigMap(); // returns by value

void example ()
{
  std::map<Big, Bigger> map;

  // ... some code using map

  createBigMap().swap(map);  // cheap swap
}

Cela a évité toute copie en raison de l'élision de copie combinée à ce qui swapprécède.

Quand j'ai remarqué qu'un compilateur utilisant le standard C ++ 11 ne comporte plus de défauts avec le code suivant:

std::vector<std::vector<int>> a;

pour soi-disant contenant opérateur >>, j'ai commencé à danser. Dans les versions antérieures, il fallait faire

std::vector<std::vector<int> > a;

Pour aggraver les choses, si jamais vous deviez déboguer cela, vous savez à quel point les messages d'erreur qui en découlent sont horribles.

Cependant, je ne sais pas si cela vous était "évident".

Le retour par valeur n'est plus un problème. Avec la sémantique de déplacement et / ou l'optimisation de la valeur de retour (dépendante du compilateur), les fonctions de codage sont plus naturelles sans frais généraux ni coût (la plupart du temps).