Parti più utilizzate di Boost [chiuso]

Quando ho scoperto boost::lexical_castho pensato a me stesso "perché non lo sapevo prima!" - Odiavo dover scrivere codice come

stringstream ss;
ss << anIntVal;
mystring = ss.str();

Adesso scrivo

mystring = boost::lexical_cast<string>(anIntVal);

Ieri, su stackoverflow, mi sono imbattuto in boost split (un'altra gemma che mi farà risparmiare la scrittura di codice).

string stringtobesplit = "AA/BB-CC")
vector<string> tokens;

boost::split(tokens, stringtobesplit, boost::is_any_of("/-")); 
// tokens now holds 3 items: AA BB CC

Inizierò a esaminare la documentazione di boost alla ricerca di altre funzioni che sarò in grado di utilizzare regolarmente, ma sento che sarà molto facile perdere le cose.

Quali funzioni di potenziamento usi di più / non ti piacerebbe avere?

Probabilmente la parte più utilizzata di boost per me è boost :: shared_ptr .

BOOST_FOREACH rende la vita di nuovo degna di essere vissuta.

(Perché nessuno ne ha parlato? La domanda è stata posta 8 mesi fa!)

I miei preferiti sono, in nessun ordine particolare:

• regex
• filesystem
• filo
• lexical_cast
• program_options (semplicemente geniale!)
• test (per tutte le mie esigenze di unit test).
• Algoritmi di stringa
• Tokenizzatore di stringhe
• format (formattazione della stringa in stile printf indipendente dai tipi)
• smart ptrs

Boost è stato di grande aiuto quando ho scritto la mia prima app multipiattaforma - senza di essa avrei davvero faticato.

Mi piace come puoi fornire il tuo distruttore per shared_ptr.
Ciò significa, ad esempio, che puoi usarlo con FILE*e farlo chiudere il file per te.
per esempio

void safeclose(FILE*fp) {
    if(fp) {
        fclose(fp);
    }
}
void some_fn() {
    boost::shared_ptr<FILE> fp( fopen(myfilename, "a+t"), safeclose );
    //body of the function, and when ever it exits the file gets closed
    fprintf( fp.get(), "a message\n" );
}

Nessuno ha menzionato i contenitori multi-indice, quindi suonerò in ritardo. Non è così spesso che ne hai bisogno, ma senza boost è un vero problema creare una struttura dati equivalente, oltre ad essere meno efficiente. Li ho usati molto di recente per creare contenitori che hanno la ricerca su 2 chiavi.

Sono sorpreso che nessuno l'abbia menzionato boost::optional. Mi ritrovo a usarlo più spesso di qualsiasi parte di Boost tranne shared_ptre scoped_ptr.

Nessuno menziona boost :: tuple? Per vergogna!

BOOST_STATIC_ASSERT

Aggiornamento (ottobre 2011): C ++ 11 (C ++ 0x) ha static_assert http://www2.research.att.com/~bs/C++0xFAQ.html#static_assert

Uno dei miei più utilizzati non è in Boost vero e proprio, ma le Adobe Source Libraries (ASL) costruite sopra Boost, in particolare, le estensioni degli algoritmi standard che accettano un boost :: range al posto di iteratori di inizio / fine separati. Allora invece di chiamare, dì

std::for_each(some_container.begin(), some_container.end(), do_something());

Posso semplicemente dire

adobe::for_each(some_container, do_something());

(Spero che queste parti dell'ASL migrino a Boost alla fine.)

Uso molto:

• boost :: segnali
• boost :: shared_ptr
• boost :: lexical_cast
• boost :: bind
• boost :: casuale
• boost :: filo
• boost :: noncopyable

Altri come Tuple, Static Assert e Integer sono molto utili se stai scrivendo una libreria che deve essere utilizzata su una varietà di piattaforme.

Cose come Grafici e Lambda sono più specifiche.

boost::shared_ptrè un requisito per la moderna programmazione C ++ IMHO. Ecco perché lo hanno aggiunto allo standard con TR1. boost::program_options, boost::binde boost::signalsono davvero carini se sai a cosa servono e come usarli. Gli ultimi due però tendono a spaventare i nuovi arrivati.

Abbiamo trovato boost :: spirit piuttosto utile per una soluzione aziendale per analizzare ECMAScript. Complesso, ma molto carino!

Sono sorpreso di non vedere ancora tra le risposte Boost.Thread .

Uso shared_ptr da anni ormai. È così utile, non c'è motivo per cui un progetto dovrebbe essere senza di esso.

Inoltre, utilizzo anche Bind / Function / Lambda per meccanismi di callback generici, particolarmente utili durante i test, nonché Format per la sostituzione sprintf generica.

Infine, è stato proprio l'altro giorno quando ho usato Variant con rabbia per risolvere un problema (un parser che poteva rispondere con un piccolo set fisso di tipi di token non correlati). La soluzione era molto elegante e ne sono molto soddisfatto.

Gli anni sono passati ei tempi sono cambiati, quindi è tempo di un aggiornamento. SharedPtr e Function fanno ora parte dello standard e Bind e Lambda sono obsoleti dalla funzionalità lambda effettiva a livello di lingua.

Uso ancora Variant (che è stato anche standardizzato, ma non ci sono ancora), Format è in gran parte sostituito da fmtlib (che è stato anche standardizzato).

La parte più importante di Boost che utilizzo è Boost.Asio. Che sta per essere standardizzato.

Usare le tuple per iterare una mappa, in questo modo:

string key, value;
BOOST_FOREACH(tie(key, value), my_map) { ... }

Usando boost assign, posso inizializzare una mappa come questa:

map<string, string> my_map = map_list_of("key1", "value1")("key2", "value2")("key3", "value3");

E utilizzando gli adattatori di intervallo e l'operatore pipe ("|") posso iterare all'indietro sui valori di una mappa (come esempio):

BOOST_FOREACH(string value, my_multimap.equal_range("X") | map_values | reversed) { ... }

Dovresti controllare boost :: program_options. Rende molto più semplice l'analisi della riga di comando.

Uso i contenitori Boost Pointer piuttosto che un contenitore STL di shared_ptrs.

Uso abbastanza spesso boost :: numeric :: ublas :: matrix .

Adoro boost :: random e boost :: asio e boost :: filesystem, tuttavia boost :: bind, boost :: circular_buffer e boost :: thread sono molto pratici, i puntatori intelligenti sono ok ma preferisco RAII invece come gestione della memoria

Ok, eccone uno nuovo che ho trovato:
invece di usare stricmp posso usare la funzione uguale di boost e passare il predicato is_iequal
ad esempio:
invece di

stricmp( "avalue", mystr.c_str() ) == 0

posso usare

equals( "avalue", mystr, is_iequal() ) 

dato:

#include <boost/algorithm/string.hpp>
using namespace boost::algorithm;

Ecco i miei due centesimi:

• boost :: scope_exit - non è necessario definire la classe RAII solo per un uso
• boost :: qualsiasi
• boost :: variant
• Boost Pointer Container Library (ptr_vector)
• Potenzia la libreria della piscina
• boost :: unordered_map / boost :: unordered_set

Uso boost::iclparecchio per la post-elaborazione del testo. Mi ha fatto risparmiare un bel po 'di tempo perché altrimenti avrei dovuto implementare la suddivisione del testo da solo ...

BOOST_FOREACH è ovunque nel mio codice :)

boost::functione boost::bindsono un must assoluto. Anche se ora lo sono std::functione std::bind. Questi aiutano davvero a ridurre la quantità di codice non necessario e sono generalmente buoni per i miei progetti (o le mie delusioni).

Ho iniziato a usare di recente boost::interprocess::message_queuee anche questo è un ottimo strumento.

Ne userei molto di più, ma Qt ha modi nativi di fare molte cose che Boost fa. Se mai dovessi programmare puro C ++, immagino che diventerei un boost::junkie:)

Quello che uso di più è ora disponibile nel TR1:

• puntatori condivisi
• classe di matrice

Ora uso anche classi pool e altre cose più specifiche.

Capisci ora che Boost è pensato per essere utile alla maggior parte dei programmatori, ecco perché è il banco di prova per la futura libreria standard.

Parlando di boost :: lexical_cast, perché qualcosa come "format" non è un membro statico nella libreria std :: string?
Quasi tutte le librerie gui hanno qualcosa come CString :: Format ("% i") o QString :: Number ("% i") che restituiscono una stringa inizializzata.

Penso che la domanda dovrebbe essere ribaltata. Quale parte del tuo boost non vorresti usare?

Nella mia esperienza praticamente tutto è interessante e utile in ogni dominio problematico.

Dovresti dedicare del tempo a esaminare la documentazione del boost per trovare le aree che coprono i tuoi interessi.

Un'eccezione può essere boost::numeric::ublasche fa il suo lavoro, ma Eigen lo fa notevolmente meglio.