Quali funzionalità Boost si sovrappongono a C ++ 11?

Ho messo le mie abilità in C ++ sullo scaffale diversi anni fa e sembra che ora, quando ne ho ancora bisogno, il panorama sia cambiato.

Ora abbiamo C ++ 11 e la mia comprensione è che si sovrappone a molte funzionalità Boost.

Esiste un riassunto in cui si trovano quelle sovrapposizioni, che le librerie Boost stanno per diventare legacy, la raccomandazione di quali funzionalità di C ++ 11 utilizzare invece di quelle di boost e quali meglio no?

Sostituibile con funzionalità o librerie del linguaggio C ++ 11

• Foreach → basato sull'intervallo per
• Funzionale / Forward → Forwarding perfetto (con riferimenti rvalue , template variadic e std :: forward )
• In Place Factory, Digitato In Place Factory → Inoltro perfetto (almeno per i casi d'uso documentati)
• Lambda → Lambda expression (in casi non polimorfici)
• Funzione locale → espressione Lambda
• Min-Max → std :: minmax , std :: minmax_element
• Rapporto → std :: rapporto
• Statico Assert → static_assert
• Discussione → <thread>, ecc. (Ma controlla questa domanda ).
• Tipo di → auto, tipo declinato
• Valore inizializzato → Inizializzazione elenco (§8.5.4 / 3)
• Matematica / Funzioni speciali → <cmath>, vedere l'elenco seguente
  • funzione gamma (tgamma), funzione log gamma (lgamma)
  • funzioni di errore (erf, erfc)
  • log1p, expm1
  • cbrt, hypot
  • acosh, asinh,atanh

TR1 (sono contrassegnati nella documentazione se si tratta di librerie TR1)

• Array → std :: array
• Bind → std :: bind
• Abilita se → std :: enable_if
• Funzione → std :: function
• Funzione membro → std :: mem_fn
• Casuale → <casuale>
• Rif → std :: ref, std :: cref
• Regex → <regex>
• Risultato di → std :: risultato_di
• Smart Ptr → std :: unique_ptr, std :: shared_ptr, std :: weak_ptr (ma boost :: intrusive_ptr non può ancora essere sostituito)
• Scambia (array di scambio) → std :: swap
• Tupla → std :: tuple
• Digita Tratti → <tipe_traits>
• Non ordinato → <unordered_set>, <unordered_map>

Funzionalità di back-port da C ++ 11:

• Atomic ← std :: atomic
• Chrono ← <crono> (vedi sotto)
• Sposta ← Riferimenti valore

Sostituibile con le funzionalità del linguaggio C ++ 17:

• String_ref → std :: string_view
• Filesystem → <filesystem> (Filesystem TS)
• Opzionale → std :: opzionale ( Library Fundamentals TS v1 )
• Any → std :: any (Library Fundamentals TS v1)
• Matematica / Funzioni speciali → <cmath>( Matematica speciale IS ), vedere l'elenco seguente
  • funzione beta
  • Polinomi di Legendre (normali / associati / sferici)
  • (normale / associato) polinomi di Legendre
  • Polinomi di Hermite
  • Funzioni di Bessel (J / Y / I / K) (Y è chiamata funzione Neumann in C ++)
  • funzioni sferiche di Bessel (j / y)
  • Integrali ellittici (incompleti / completi) di (primo / secondo / terzo tipo)
  • Funzione zeta di Riemann
  • integrale esponenziale Ei
• Variante → std :: variant ( P0088R2 )

Il team standard ci sta ancora lavorando:

• Fattore comune matematico → std :: experimetal :: gcd, mcm (Library Fundamentals TS v2)
• Verifica concettuale → Concetti TS
• Gamma → Gamma TS
• Asio → Networking TS (solo socket e timer)
• Multiprecisione → Numerics TS
• Coroutine / Coroutine2 → Coroutine TS

Una gran parte di MPL può essere ridotta o rimossa usando modelli variadici. Alcuni casi di utilizzo comune di fusione lessicale possono essere sostituiti da std :: to_string e std :: sto X .

Alcune librerie Boost sono correlate a C ++ 11 ma hanno anche alcune estensioni, ad esempio Boost.Functional / Hash contiene hash_combine e funzioni correlate non presenti in C ++ 11, Boost.Chrono ha I / O e arrotondamenti e molti altri orologi, ecc. quindi potresti voler dare un'occhiata a quelli boost prima di scartarli davvero.

In realtà, non credo che le librerie boost diventeranno legacy.

Sì, si dovrebbe essere in grado di utilizzare std::type_traits, regex, shared_ptr, unique_ptr, tuple<>, std::tie, std::begininvece di Typetraits Boost / Utility, Boost smart pointer, Boost Tuple, Boost librerie Gamma, ma ci deve essere in realtà alcuna reale necessità di 'passare' a meno che non ci si sposta più di il tuo codice in c ++ 11.

Inoltre, nella mia esperienza, le stdversioni della maggior parte di questi sono in qualche modo meno caratterizzate. Ad esempio AFAICT lo standard non ha

• Perl5 espressioni regolari
• call_traits
• Alcuni membri dell'interfaccia regex (come bool boost::basic_regex<>::empty()) e altre differenze di interfaccia
  • questo morde di più poiché l'interfaccia Boost è esattamente abbinata a Boost Xpressive
  • e gioca molto più bene con Boost String Algorithms Ovviamente, questi ultimi non hanno controparti standard (ancora?)
• Molte cose relative a TMP (Boost Fusion)

• Lambdas pigri, basati su modelli di espressione; hanno inevitabili benefici in quanto possono essere polimorfici oggi , al contrario di C ++ 11. Pertanto possono spesso essere più concisi:

   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);

  Sicuramente, questo ha ancora un certo fascino su C ++ 11 lambdas (con tipi di ritorno finali, acquisizione esplicita e parametri dichiarati).

Inoltre, c'è un ruolo GRANDE per Boost, proprio nel facilitare la migrazione di percorsi da C ++ 03 a C ++ 11 e nell'integrazione di codebase C ++ 11 e C ++ 03. Sto pensando in particolare

• Boost Auto (BOOST_AUTO)
• Boost Utility ( boost::result_of<>e relative)
• Boost Foreach (BOOST_FOREACH)
• Non dimenticare: Boost Move - che consente di scrivere classi con semantica di movimento con una sintassi che si compila ugualmente bene sui compilatori C ++ 03 con i compilatori Boost 1_48 + e C ++ 11.

Solo i miei $ 0,02