Die am häufigsten verwendeten Teile von Boost [geschlossen]

Als ich entdeckte boost::lexical_cast dachte ich mir: "Warum wusste ich nicht früher davon?" - Ich hasste es, Code schreiben zu müssen

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

Jetzt schreibe ich

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

Gestern bin ich beim Stackoverflow auf Boost Split gestoßen (ein weiteres Juwel, das mir das Schreiben von Code erspart).

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

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

Ich werde anfangen, die Boost-Dokumentation nach anderen Funktionen zu durchsuchen, die ich regelmäßig verwenden kann, aber ich denke, dass es sehr leicht sein wird, Dinge zu übersehen.

Welche Boost-Funktionen verwenden Sie am meisten / würden es hassen, nicht zu haben?

Der wahrscheinlich am häufigsten verwendete Teil von Boost ist für mich boost :: shared_ptr .

BOOST_FOREACH macht das Leben wieder lohnenswert.

(Warum hat das niemand erwähnt? Die Frage wurde vor 8 Monaten gestellt!)

Meine Favoriten sind in keiner bestimmten Reihenfolge:

• Regex
• Dateisystem
• Faden
• lexical_cast
• program_options (einfach genial!)
• Test (für alle meine Unit-Test-Anforderungen).
• String-Algorithmen
• String-Tokenizer
• Format (typsichere Formatierung von Zeichenfolgen im printf-Stil)
• intelligente ptrs

Boost war eine große Hilfe, als ich meine erste plattformübergreifende App schrieb - ohne sie hätte ich wirklich Probleme gehabt.

Mir gefällt, wie Sie Ihren eigenen Destruktor für liefern können shared_ptr.
Dies bedeutet beispielsweise, dass Sie es verwenden können FILE*, um die Datei für Sie zu schließen.
z.B

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

Niemand hat Multi-Index-Container erwähnt daher werde ich mich spät melden. Es kommt nicht so oft vor, dass Sie sie benötigen, aber ohne Boost ist es ein echtes Problem, eine gleichwertige Datenstruktur zu erstellen und weniger effizient zu sein. Ich habe sie in letzter Zeit häufig verwendet, um Container zu erstellen, die auf 2 Schlüsseln nachgeschlagen haben.

Ich bin überrascht, dass niemand erwähnt hat boost::optional. Ich benutze es öfter als irgendeinen Teil von Boost außer shared_ptrund scoped_ptr.

Niemand erwähnt boost :: tuple? Zum Schämen!

BOOST_STATIC_ASSERT

Update (Oktober 2011): C ++ 11 (C ++ 0x) hat static_assert http://www2.research.att.com/~bs/C++0xFAQ.html#static_assert

Eine meiner am häufigsten verwendeten ist nicht Boost, sondern die Adobe Source Libraries (ASL), die auf Boost aufbauen - insbesondere die Erweiterungen der Standardalgorithmen, die einen Boost :: -Bereich anstelle separater Start- / End-Iteratoren akzeptieren. Dann, anstatt anzurufen, sagen wir:

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

Ich kann einfach sagen

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

(Ich hoffe, dass diese Teile von ASL irgendwann zu Boost migrieren.)

Ich benutze viel:

• Boost :: Signale
• boost :: shared_ptr
• boost :: lexical_cast
• boost :: bind
• boost :: random
• boost :: thread
• boost :: nicht kopierbar

Andere wie Tuple, Static Assert und Integer sind sehr nützlich, wenn Sie eine Bibliothek schreiben, die auf einer Vielzahl von Plattformen verwendet werden soll.

Dinge wie Graphs und Lambda sind spezifischer.

boost::shared_ptrist eine Voraussetzung für die moderne C ++ - Programmierung IMHO. Deshalb haben sie es mit TR1 zum Standard hinzugefügt. boost::program_options, boost::bindUnd boost::signalsind wirklich nett , wenn Sie wissen , was sie sind und wie sie zu benutzen. Die letzten beiden neigen jedoch dazu, Neuankömmlinge zu erschrecken.

Wir fanden boost :: spirit ziemlich nützlich für eine Geschäftslösung zum Parsen von ECMAScript. Komplex, aber sehr schön!

Ich bin überrascht, noch nicht zwischen den Antworten Boost.Thread zu sehen .

Ich benutze shared_ptr seit Jahren. Es ist einfach so nützlich, es gibt keinen Grund, warum ein Projekt ohne es sein sollte.

Darüber hinaus verwende ich Bind / Function / Lambda für generische Rückrufmechanismen - besonders nützlich beim Testen - sowie Format für meinen allgemeinen Sprintf-Ersatz.

Schließlich war es erst neulich, als ich Variant in Wut verwendete, um ein Problem zu lösen (ein Parser, der mit einem kleinen, festen Satz nicht verwandter Token-Typen antworten konnte). Die Lösung war sehr elegant und ich bin sehr zufrieden damit.

Jahre sind vergangen und die Zeiten haben sich geändert, also Zeit für ein Update. SharedPtr und Function sind jetzt Teil des Standards, und Bind und Lambda sind durch die tatsächliche Lambda-Funktionalität auf Sprachebene überholt.

Ich verwende immer noch Variant (das ebenfalls standardisiert wurde, aber ich bin noch nicht da). Das Format wird größtenteils durch fmtlib (das ebenfalls standardisiert wurde) ersetzt.

Der große Teil von Boost, den ich benutze, ist Boost.Asio. Welches ist im Begriff, standardisiert zu werden.

Verwenden von Tupeln zum Iterieren einer Karte wie folgt:

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

Mit Boost Assign kann ich eine Karte wie folgt initialisieren:

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

Und mit Bereichsadaptern und dem Pipe-Operator ("|") kann ich die Werte einer Karte rückwärts durchlaufen (als Beispiel):

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

Sie sollten boost :: program_options überprüfen. Dies erleichtert das Parsen von Befehlszeilen erheblich.

Ich benutze Boost Pointer Container vor einem STL Container von shared_ptrs.

Ich benutze Boost :: Numeric :: Ublas :: Matrix ziemlich oft .

Ich liebe boost :: random und boost :: asio und boost :: filesystem, aber boost :: bind, boost :: Circular_buffer und boost :: thread sind sehr praktisch, intelligente Zeiger sind in Ordnung, aber ich bevorzuge RAII als Speicherverwaltung

Okay, hier ist eine neue, die ich gefunden habe:
Anstatt stricmp zu verwenden, kann ich die Gleichheitsfunktion von boost verwenden und das Prädikat is_iequal übergeben,
z. B.:
Anstelle von

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

ich kann nutzen

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

gegeben:

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

Hier sind meine zwei Cent:

• boost :: scope_exit - Die RAII-Klasse muss nicht nur für eine Verwendung definiert werden
• boost :: any
• boost :: variante
• Boost Pointer Container Library (ptr_vector)
• Boost Pool Bibliothek
• boost :: unordered_map / boost :: unordered_set

ich benutze boost::icl ziemlich viel für die Textnachbearbeitung. Das hat mir ziemlich viel Zeit gespart, da ich sonst die Textaufteilung selbst implementieren müsste ...

BOOST_FOREACH ist überall in meinem Code :)

boost::functionund boost::bindsind ein absolutes Muss. Obwohl sie jetzt std::functionund sindstd::bind . Diese helfen wirklich dabei, die Menge an unnötigem Code zu reduzieren und sind im Allgemeinen gut für meine Designs (oder meine Wahnvorstellungen).

Ich habe vor kurzem angefangen zu verwenden boost::interprocess::message_queue und dies ist auch ein großartiges Werkzeug.

Ich würde viel mehr verwenden, aber Qt hat native Methoden, um viele Dinge zu tun, die Boost tut. Wenn ich jemals reines C ++ programmieren müsste, würde ich wahrscheinlich ein boost::junkie:) werden

Was ich am häufigsten benutze, ist jetzt im TR1 verfügbar:

• gemeinsame Zeiger
• Array-Klasse

Jetzt benutze ich auch Poolklassen und einige andere spezifischere Dinge.

Sie verstehen jetzt, dass Boost für die meisten Programmierer nützlich sein soll. Deshalb ist es der Prüfstand für die zukünftige Standardbibliothek.

Wenn wir über boost :: lexical_cast sprechen, warum ist so etwas wie 'format' kein statisches Mitglied in der std :: string-Bibliothek?
Fast alle GUI-Bibliotheken haben so etwas wie CString :: Format ("% i") oder QString :: Number ("% i"), die eine initialisierte Zeichenfolge zurückgeben.

Ich denke, die Frage sollte umgekehrt werden. Welchen Teil Ihres Boosts möchten Sie nicht nutzen?

Nach meiner Erfahrung ist so ziemlich alles in jedem Problembereich interessant und nützlich.

Sie sollten sich in der Boost-Dokumentation umsehen, um die Bereiche zu finden, die Ihre Interessen abdecken.

Eine Ausnahme mag sein, boost::numeric::ublasdass es seinen Job macht, aber Eigen macht es bemerkenswert besser.