Parties les plus utilisées de Boost [fermé]

Quand j'ai découvert, boost::lexical_castje me suis dit "pourquoi n'ai-je pas su cela plus tôt!" - Je détestais avoir à écrire du code comme

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

Maintenant j'écris

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

Hier, sur stackoverflow, je suis tombé sur boost split (un autre joyau qui me permettra d'économiser du code).

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

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

Je vais commencer à chercher dans la documentation de boost à la recherche d'autres fonctions que je pourrai utiliser régulièrement, mais je pense qu'il sera très facile de rater des choses.

Quelles fonctions de boost utilisez-vous le plus / détesteriez-vous ne pas avoir?

La partie de boost la plus utilisée pour moi est probablement boost :: shared_ptr .

BOOST_FOREACH redonne du sens à la vie.

(Pourquoi personne n'a mentionné cela? La question a été posée il y a 8 mois!)

Mes favoris sont, sans ordre particulier:

• regex
• système de fichiers
• fil
• lexical_cast
• program_options (tout simplement génial!)
• test (pour tous mes besoins en tests unitaires).
• Algorithmes de chaîne
• Tokenizer de chaîne
• format (formatage de chaîne de style printf sécurisé)
• ptrs intelligents

Boost a été d'une grande aide lorsque j'ai écrit ma première application multiplateforme - sans cela, j'aurais vraiment eu du mal.

J'aime la façon dont vous pouvez fournir votre propre destructeur shared_ptr.
Cela signifie, par exemple, que vous pouvez l'utiliser avec FILE*et l'obtenir pour fermer le fichier pour vous.
par exemple

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

Personne n'a mentionné les conteneurs multi-index , je vais donc sonner tard. Ce n'est pas si souvent que vous en avez besoin, mais sans boost, c'est vraiment pénible de créer une structure de données équivalente, tout en étant moins efficace. Je les ai beaucoup utilisés récemment pour créer des conteneurs qui recherchent 2 clés.

Je suis surpris que personne ne l'ait mentionné boost::optional. Je me retrouve à l'utiliser plus souvent que n'importe quelle partie de Boost sauf shared_ptret scoped_ptr.

Personne ne mentionne boost :: tuple? Pour la honte!

BOOST_STATIC_ASSERT

Mise à jour (octobre 2011): C ++ 11 (C ++ 0x) a static_assert http://www2.research.att.com/~bs/C++0xFAQ.html#static_assert

L'un de mes plus utilisés n'est pas Boost proprement dit, mais les bibliothèques Adobe Source (ASL) construites au-dessus de Boost - en particulier, les extensions des algorithmes standard qui acceptent un boost :: range à la place d'itérateurs de début / fin séparés. Alors au lieu d'appeler, disons

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

Je peux simplement dire

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

(J'espère que ces parties d'ASL migreront éventuellement vers Boost.)

J'utilise beaucoup:

• boost :: signaux
• boost :: shared_ptr
• boost :: lexical_cast
• boost :: bind
• boost :: aléatoire
• boost :: thread
• boost :: non copiable

D'autres comme Tuple, Static Assert et Integer sont très utiles si vous écrivez une bibliothèque qui doit être utilisée sur une variété de plates-formes.

Des choses comme les graphiques et Lambda sont plus spécifiques.

boost::shared_ptrest une exigence pour la programmation C ++ moderne IMHO. C'est pourquoi ils l'ont ajouté à la norme avec TR1. boost::program_options, boost::bindet boost::signalsont vraiment sympas si vous savez à quoi ils servent et comment les utiliser. Les deux derniers ont tendance à effrayer les nouveaux arrivants.

Nous avons trouvé boost :: spirit assez utile pour une solution commerciale pour analyser ECMAScript. Complexe, mais très agréable!

Je suis surpris de ne pas encore voir entre les réponses Boost.Thread .

J'utilise shared_ptr depuis des années maintenant. C'est tellement utile qu'il n'y a aucune raison pour qu'un projet s'en prive.

En plus de cela, j'utilise également Bind / Function / Lambda pour les mécanismes de rappel génériques - particulièrement utiles lors des tests - ainsi que Format pour mon remplacement de sprintf à usage général.

Enfin, c'était juste l'autre jour que j'ai utilisé Variant dans la colère pour résoudre un problème (un analyseur qui pouvait répondre avec un petit ensemble fixe de types de jetons non liés). La solution était très élégante et j'en suis très content.

Les années ont passé et les temps ont changé, il est donc temps de faire une mise à jour. SharedPtr et Function font désormais partie de la norme, et Bind et Lambda sont obsolètes par la fonctionnalité lambda au niveau du langage.

J'utilise toujours Variant (qui a également été standardisé, mais je n'y suis pas encore), Format est largement remplacé par fmtlib (qui a également été standardisé).

La grande partie de Boost que j'utilise est Boost.Asio. Qui est en cours de normalisation.

Utilisation de tuples pour itérer une carte, comme ceci:

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

En utilisant boost assign, je peux initialiser une carte comme celle-ci:

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

Et en utilisant des adaptateurs de plage et l'opérateur pipe ("|"), je peux parcourir les valeurs d'une carte (à titre d'exemple):

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

Vous devriez vérifier boost :: program_options. Cela rend l'analyse de la ligne de commande beaucoup plus facile.

J'utilise Boost Pointer Containers de préférence à un conteneur STL de shared_ptrs.

J'utilise assez souvent boost :: numeric :: ublas :: matrix .

J'adore boost :: random et boost :: asio et boost :: filesystem, mais boost :: bind, boost :: circular_buffer et boost :: thread sont très pratiques, les pointeurs intelligents sont ok mais je préfère RAII à la place comme gestion de la mémoire

D'accord, voici un nouveau que j'ai trouvé: au
lieu d'utiliser stricmp, je peux utiliser la fonction equals de boost et passer le prédicat is_iequal,
par exemple:
au lieu de

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

je peux utiliser

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

donné:

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

Voici mes deux cents:

• boost :: scope_exit - pas besoin de définir la classe RAII juste pour une seule utilisation
• boost :: any
• boost :: variante
• Bibliothèque de conteneurs Boost Pointer (ptr_vector)
• Boost Pool Library
• boost :: unordered_map / boost :: unordered_set

J'utilise boost::iclbeaucoup pour le post-traitement de texte. Cela m'a fait gagner beaucoup de temps car sinon, je devrais implémenter moi-même la division de texte ...

BOOST_FOREACH est partout dans mon code :)

boost::functionet boost::bindsont un must absolu. Bien que maintenant ils soient std::functionetstd::bind . Celles-ci aident vraiment à réduire la quantité de code inutile et sont généralement bonnes pour mes créations (ou mes illusions).

J'ai récemment commencé à utiliser boost::interprocess::message_queue et c'est aussi un excellent outil.

J'en utiliserais beaucoup plus, mais Qt a des moyens natifs de faire beaucoup de choses que Boost fait. Si jamais je dois programmer du C ++ pur, je suppose que je deviendrais boost::junkie:)

Ce que j'utilise le plus est maintenant disponible dans le TR1:

• pointeurs partagés
• classe de tableau

Maintenant, j'utilise également des classes de piscine et d'autres choses plus spécifiques.

Vous comprenez maintenant que Boost est censé être utile à la plupart des programmeurs, c'est pourquoi c'est le banc d'essai de la future bibliothèque standard.

En parlant de boost :: lexical_cast, pourquoi quelque chose comme 'format' n'est-il pas un membre statique dans la bibliothèque std :: string?
Presque toutes les bibliothèques d'interface graphique ont quelque chose comme CString :: Format ("% i") ou QString :: Number ("% i") qui retournent une chaîne initialisée.

Je pense que la question devrait être inversée. Quelle partie de votre boost ne voudriez-vous pas utiliser?

D'après mon expérience, presque tout cela est intéressant et utile dans chaque domaine problématique.

Vous devriez passer du temps à parcourir la documentation du boost pour trouver les domaines qui couvrent vos intérêts.

Une exception peut être celle boost::numeric::ublasqui fait son travail, mais Eigen le fait remarquablement mieux.