Najczęściej używane części Boost [zamknięte]

Kiedy odkryłem boost::lexical_cast, pomyślałem sobie „dlaczego nie wiedziałem o tym wcześniej!” - Nienawidziłem pisania kodu

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

Teraz piszę

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

Wczoraj na stackoverflow natknąłem się na Boost Split (kolejny klejnot, który pozwoli mi zaoszczędzić na pisaniu kodu).

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

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

Zacznę przeglądać dokumentację doładowania, szukając innych funkcji, z których będę mógł regularnie korzystać, ale czuję, że bardzo łatwo będzie coś przeoczyć.

Jakich funkcji doładowania używasz najczęściej / których nie chciałbyś mieć?

Prawdopodobnie najczęściej używaną częścią boostu jest dla mnie boost :: shared_ptr .

BOOST_FOREACH sprawia, że ​​życie znów jest warte zachodu .

(Dlaczego nikt o tym nie wspomniał? Pytanie zadano 8 miesięcy temu!)

Moje ulubione to, w przypadkowej kolejności:

• wyrażenie regularne
• system plików
• wątek
• lexical_cast
• program_options (po prostu genialne!)
• test (dla wszystkich moich potrzeb związanych z testowaniem jednostkowym).
• Algorytmy ciągów
• Tokenizer ciągu
• format (bezpieczne formatowanie napisów w stylu printf)
• smart ptrs

Boost był ogromną pomocą, kiedy napisałem swoją pierwszą aplikację wieloplatformową - bez niej naprawdę miałbym problemy.

Podoba mi się, jak możesz dostarczyć własnego destruktora shared_ptr.
Oznacza to na przykład, że możesz go użyć z FILE*i zmusić do zamknięcia pliku.
na przykład

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

Nikt nie wspomniał o kontenerach z wieloma indeksami, więc zadzwonię późno. Nie jest tak często, że ich potrzebujesz, ale bez wzmocnienia tworzenie równoważnej struktury danych jest bardzo trudne, a także mniej wydajne. Ostatnio często ich używałem do tworzenia kontenerów, które wyszukują 2 klucze.

Dziwię się, że nikt o tym nie wspomniał boost::optional. Używam go częściej niż jakiejkolwiek części Boost, z wyjątkiem shared_ptri scoped_ptr.

Nikt nie wspomina o boostie :: tuple? Wstyd!

BOOST_STATIC_ASSERT

Aktualizacja (październik 2011): C ++ 11 (C ++ 0x) ma static_assert http://www2.research.att.com/~bs/C++0xFAQ.html#static_assert

Jednym z najczęściej używanych przeze mnie nie jest poprawne Boost, ale Adobe Source Libraries (ASL) zbudowane na bazie Boost - w szczególności rozszerzenia standardowych algorytmów, które akceptują wzmocnienie :: range zamiast oddzielnych iteratorów początku / końca. Wtedy zamiast dzwonić, powiedz:

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

Mogę po prostu powiedzieć

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

(Mam nadzieję, że te części ASL w końcu przejdą na Boost.)

Używam dużo:

• boost :: sygnały
• boost :: shared_ptr
• boost :: lexical_cast
• boost :: bind
• boost :: random
• boost :: thread
• boost :: noncopyable

Inne, takie jak Tuple, Static Assert i Integer, są bardzo przydatne, jeśli piszesz bibliotekę, która ma być używana na różnych platformach.

Rzeczy takie jak wykresy i Lambda są bardziej szczegółowe.

boost::shared_ptrjest wymogiem dla nowoczesnego programowania IMHO w C ++. Dlatego dodali go do standardu z TR1. boost::program_options, boost::bindi boost::signalsą naprawdę fajne, jeśli wiesz, do czego służą i jak ich używać. Dwie ostatnie mają jednak tendencję do straszenia nowoprzybyłych.

Okazało się, że funkcja boost :: spirit jest całkiem przydatna w rozwiązaniu biznesowym do analizowania ECMAScript. Złożone, ale bardzo ładne!

Jestem zaskoczony, że nie widzę jeszcze odpowiedzi między odpowiedziami Boost.Thread .

Używam shared_ptr od lat. Jest po prostu tak przydatny, że nie ma powodu, aby projekt był bez niego.

Co więcej, używam również Bind / Function / Lambda do ogólnych mechanizmów wywołania zwrotnego - szczególnie przydatnego podczas testowania - a także Format do mojego zamiennika sprintf ogólnego przeznaczenia.

Wreszcie, dopiero niedawno użyłem Variant w złości, aby rozwiązać problem (parser, który mógł odpowiedzieć za pomocą małego, ustalonego zestawu niepowiązanych typów tokenów). Rozwiązanie było bardzo eleganckie i jestem z niego bardzo zadowolony.

Minęły lata i czasy się zmieniły, więc czas na aktualizację. SharedPtr i Function są teraz częścią standardu, a Bind i Lambda są przestarzałe przez rzeczywistą funkcjonalność lambda na poziomie języka.

Nadal używam Variant (który również został ustandaryzowany, ale jeszcze tam nie jestem), format jest w dużej mierze zastępowany przez fmtlib (który również został ustandaryzowany).

Duża część Boost, której używam, to Boost.Asio. Który jest w trakcie standaryzacji.

Używanie krotek do iteracji mapy, na przykład:

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

Korzystając z przypisania doładowania, mogę zainicjować mapę w następujący sposób:

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

Używając adapterów zakresu i operatora potoku („|”) mogę iterować wstecz po wartościach mapy (jako przykład):

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

Powinieneś sprawdzić boost :: program_options. To znacznie ułatwia analizowanie wiersza poleceń.

Używam kontenerów Boost Pointer Containers zamiast kontenera STL shared_ptrs.

Często używam boost :: numeric :: ublas :: matrix .

Uwielbiam boost :: random i boost :: asio i boost :: filesystem, jednak boost :: bind, boost :: round_buffer i boost :: thread są bardzo praktyczne, inteligentne wskaźniki są w porządku, ale wolę RAII zamiast zarządzania pamięcią

Okay, oto nowy, który znalazłem:
Zamiast używać stricmp mogę użyć funkcji equals boost i przekazać w predykacie is_iequal,
np .:
zamiast

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

mogę użyć

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

dany:

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

Oto moje dwa centy:

• boost :: scope_exit - nie ma potrzeby definiowania klasy RAII tylko do jednego użycia
• boost :: any
• boost :: variant
• Wzmocnij bibliotekę kontenerów wskaźników (ptr_vector)
• Zwiększ bibliotekę puli
• boost :: unordered_map / boost :: unordered_set

Używam boost::icldużo do przetwarzania tekstu. Zaoszczędziło mi to sporo czasu, bo inaczej musiałbym sam zaimplementować dzielenie tekstu ...

BOOST_FOREACH jest wszędzie w moim kodzie :)

boost::functioni boost::bindsą absolutną koniecznością. Chociaż teraz są std::functioni std::bind. To naprawdę pomaga zmniejszyć ilość niepotrzebnego kodu i ogólnie jest dobre dla moich projektów (lub moich złudzeń).

Niedawno zacząłem używać boost::interprocess::message_queuei jest to również świetne narzędzie.

Używałbym znacznie więcej, ale Qt ma natywne sposoby robienia wielu rzeczy, które robi Boost. Gdybym kiedykolwiek musiał programować w czystym C ++, myślę, że zostałbym boost::junkie:)

To, czego używam najczęściej, jest teraz dostępne w TR1:

• wspólne wskaźniki
• klasa tablicy

Teraz używam również zajęć z puli i kilku innych bardziej szczegółowych rzeczy.

Rozumiesz teraz, że Boost ma być przydatny dla większości programistów, dlatego jest polem testowym dla przyszłej biblioteki standardowej.

Mówiąc o boost :: lexical_cast, dlaczego coś takiego jak „format” nie jest statycznym składnikiem w bibliotece std :: string?
Prawie wszystkie biblioteki gui mają coś takiego jak CString :: Format ("% i") lub QString :: Number ("% i"), które zwracają zainicjowany ciąg.

Myślę, że pytanie powinno zostać odwrócone. Której części twojego boostu nie chciałbyś używać?

Z mojego doświadczenia wynika, że ​​prawie wszystko jest interesujące i przydatne w każdej problematycznej domenie.

Powinieneś poświęcić czas na rozejrzenie się po dokumentacji doładowania, aby znaleźć obszary, które obejmują twoje zainteresowania.

Jedynym wyjątkiem może być boost::numeric::ublasto, że spełnia swoje zadanie, ale Eigen robi to znacznie lepiej.