Quelles fonctionnalités Boost chevauchent C ++ 11?

J'ai mis mes compétences C ++ sur l'étagère il y a plusieurs années et il semble que maintenant, quand j'en ai à nouveau besoin, le paysage a changé.

Nous avons maintenant C ++ 11, et je crois comprendre qu'il chevauche de nombreuses fonctionnalités Boost.

Existe-t-il un résumé de ces chevauchements, des bibliothèques Boost qui vont devenir héritées, des recommandations sur les fonctionnalités C ++ 11 à utiliser au lieu de celles boostées et lesquelles ne sont pas meilleures?

Remplaçable par les fonctionnalités ou bibliothèques du langage C ++ 11

• Foreach → basé sur la plage pour
• Fonctionnel / Forward → Transfert parfait (avec références rvalue , modèles variadiques et std :: forward )
• In Place Factory, Typed In Place Factory → Transfert parfait (au moins pour les cas d'utilisation documentés)
• Expression Lambda → Lambda (dans les cas non polymorphes)
• Fonction locale → Expression Lambda
• Min-Max → std :: minmax , std :: minmax_element
• Ratio → std :: ratio
• Assertion statique → static_assert
• Thread → <thread>, etc. (mais vérifiez cette question ).
• Typeof → auto, decltype
• Valeur initialisée → Initialisation de la liste (§8.5.4 / 3)
• Fonctions mathématiques / spéciales → <cmath>, voir la liste ci-dessous
  • fonction gamma (tgamma), fonction log gamma (lgamma)
  • fonctions d'erreur (erf, erfc)
  • log1p, expm1
  • cbrt, hypot
  • acosh, asinh,atanh

TR1 (ils sont marqués dans la documentation s'il s'agit de bibliothèques TR1)

• Tableau → std :: tableau
• Bind → std :: bind
• Activer si → std :: enable_if
• Fonction → std :: function
• Fonction membre → std :: mem_fn
• Aléatoire → <aléatoire>
• Réf → std :: ref, std :: cref
• Regex → <regex>
• Résultat de → std :: result_of
• Smart Ptr → std :: unique_ptr, std :: shared_ptr, std :: low_ptr (mais boost :: intrusive_ptr ne peut toujours pas être remplacé)
• Swap (permutation de tableaux) → std :: swap
• Tuple → std :: tuple
• Traits de type → <type_traits>
• Non ordonné → < unordered_set >, <unordered_map>

Fonctionnalités back-portées à partir de C ++ 11:

• Atomique ← std :: atomique
• Chrono ← <chrono> (voir ci-dessous)
• Déplacer ← Références Rvalue

Remplaçable par les fonctionnalités du langage C ++ 17:

• String_ref → std :: string_view
• Système de fichiers → <système de fichiers> (système de fichiers TS)
• Facultatif → std :: facultatif ( Library Fundamentals TS v1 )
• Any → std :: any (Library Fundamentals TS v1)
• Math / Fonctions spéciales → <cmath>( Special Math IS ), voir la liste ci-dessous
  • fonction bêta
  • (normal / associé / sphérique) Polynômes de Legendre
  • (normal / associé) Polynômes de Legendre
  • Polynômes Hermite
  • Fonctions de Bessel (J / Y / I / K) (Y est appelée fonction de Neumann en C ++)
  • fonctions sphériques de Bessel (j / y)
  • (incomplète / complète) intégrales elliptiques de (premier / deuxième / troisième type)
  • Fonction zêta de Riemann
  • intégrale exponentielle Ei
• Variante → std :: variante ( P0088R2 )

L'équipe standard y travaille toujours:

• Math Common Factor → std :: experimetal :: gcd, lcm (Library Fundamentals TS v2)
• Vérification du concept → Concepts TS
• Gamme → Gamme TS
• Asio → Networking TS (sockets et minuteries uniquement)
• Multiprécision → Numérique TS
• Coroutine / Coroutine2 → Coroutines TS

Une grande partie de MPL peut être réduite ou supprimée à l'aide de modèles variadiques. Certains cas d'utilisation commune de fonte lexicales peuvent être remplacés par std :: to_string et std :: sto X .

Certaines bibliothèques Boost sont liées à C ++ 11 mais ont également d'autres extensions, par exemple Boost.Functional / Hash contient hash_combine et des fonctions associées non trouvées dans C ++ 11, Boost.Chrono a des E / S et des arrondis et de nombreuses autres horloges, etc., vous voudrez peut-être toujours jeter un coup d'œil aux boosters avant de vraiment les rejeter.

En fait, je ne pense pas que les bibliothèques boost deviendront héritées.

Oui, vous devriez être en mesure d'utiliser std::type_traits, regex, shared_ptr, unique_ptr, tuple<>, std::tie,std::begin au lieu de Typetraits Boost / Utility, Boost pointeur intelligent, Boost Tuple, Bibliothèques Boost Range, mais il devrait en pratique pas vraiment besoin de « switch » à moins que vous déplacez plus votre code en c ++ 11.

De plus, d'après mon expérience, les stdversions de la plupart d'entre elles sont un peu moins fonctionnelles. Par exemple , la norme AFAICT ne pas avoir

• Expressions régulières Perl5
• call_traits
• Certains membres d'interface regex (tels que bool boost::basic_regex<>::empty()) et d'autres différences d'interface
  • cela mord plus car l'interface Boost est exactement adaptée à Boost Xpressive
  • et il joue beaucoup plus bien avec les algorithmes Boost String Evidemment, ces derniers n'ont pas d' équivalents standards (encore?)
• Beaucoup de choses concernant TMP (Boost Fusion)

• Lambdas paresseux basés sur un modèle d'expression; ils ont des avantages inévitables dans la mesure où ils peuvent être polymorphes aujourd'hui , contrairement au C ++ 11. Par conséquent, ils peuvent souvent être plus succincts:

   std::vector<int> v = {1,2,-9,3};
  
   for (auto i : v | filtered(_arg1 >=0))
       std::cout << i << "\n";
  
   // or:
   boost::for_each(v, std::cout << _arg1);

  Très certainement, cela a encore un certain attrait sur les lambdas C ++ 11 (avec les types de retour de fin, la capture explicite et les paramètres déclarés).

De plus, il y a un GRAND rôle pour Boost, précisément en facilitant la migration par chemin de C ++ 03 vers C ++ 11 et en intégrant les bases de code C ++ 11 et C ++ 03. Je pense particulièrement à

• Boost Auto (BOOST_AUTO)
• Boost Utility ( boost::result_of<>et associé)
• Boost Foreach (BOOST_FOREACH)
• N'oubliez pas: Boost Move - qui permet d'écrire des classes avec une sémantique de déplacement avec une syntaxe qui se compilera aussi bien sur des compilateurs C ++ 03 avec des compilateurs Boost 1_48 + et C ++ 11.

Juste mon 0,02 $