Pièces les plus utilisées de Boost
Quand j'ai découvert boost::lexical_cast Je me suis dit "pourquoi je ne l'ai pas su plus tôt!" - Je détestais devoir é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 fera é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 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 vie à 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
- thread
- lexical_cast
- programme_options (tout simplement génial!)
- test (pour tous mes besoins de tests unitaires).
- Algorithmes de chaîne
- Tokenizer de chaîne
- format (formatage de chaîne de style printf sûr)
- ptrs intelligents
Boost a été d'une aide considérable lorsque j'ai écrit ma première application multiplateforme - sans elle, j'aurais vraiment eu du mal.
J'aime la façon dont vous pouvez fournir votre propre destructeur pour shared_ptr.
Cela signifie, par exemple, que vous pouvez l'utiliser avec FILE* et faites-le 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é conteneurs multi-index donc je vais carillon tard. Ce n'est pas si souvent que vous en avez besoin, mais sans boost, c'est vraiment difficile de créer une structure de données équivalente, tout en étant moins efficace. Je les utilise beaucoup récemment pour créer des conteneurs qui recherchent 2 clés.
Je suis surpris que personne n'ait mentionné boost::optional. Je me retrouve à l'utiliser plus souvent que n'importe quelle partie de Boost sauf shared_ptr et scoped_ptr.
Personne ne mentionne boost :: tuple? Dommage!
Mise à jour (octobre 2011): C++ 11 (C++ 0x) a static_asserthttp://www2.research.att.com/~bs/C++0xFAQ.html#static_assert
L'une de mes plus utilisées n'est pas dans Boost proprement dit, mais les Adobe Source Libraries (ASL) construites au-dessus de Boost - en particulier, les extensions des algorithmes standard qui acceptent une gamme boost :: au lieu de itérateurs de début/fin séparés. Au lieu d'appeler, par exemple,
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 de l'ASL finiront par migrer vers Boost.)
boost::shared_ptr est une exigence pour la programmation C++ moderne à mon humble avis. C'est pourquoi ils l'ont ajouté à la norme avec TR1. boost::program_options, boost::bind, et boost::signal sont vraiment sympas si vous savez à quoi ils servent et comment les utiliser. Les deux derniers ont cependant tendance à effrayer les nouveaux arrivants.
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 Graphs et Lambda sont plus spécifiques.
Je suis surpris de ne pas encore voir entre les réponses Boost.Thread .
Nous avons trouvé boost :: spirit assez utile pour une solution commerciale pour analyser ECMAScript. Complexe, mais très agréable!
J'utilise shared_ptr depuis des années maintenant. C'est tellement utile, il n'y a aucune raison qu'un projet soit sans lui.
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 quand j'ai utilisé Variant en colère pour résoudre un problème (un analyseur qui pouvait répondre avec un petit ensemble fixe de types de jetons indépendants). La solution était très élégante et j'en suis très heureuse.
Les années ont passé et les temps ont changé, alors le temps d'une mise à jour. SharedPtr et Function font désormais partie de la norme, et Bind et Lambda sont obsolètes par la fonctionnalité lambda réelle au niveau de la langue.
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 standardisation.
Utiliser des 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 de tuyau ("|"), je peux parcourir les valeurs d'une carte en arrière (par exemple):
BOOST_FOREACH(string value, my_multimap.equal_range("X") | map_values | reversed) { ... }
Vous devriez vérifier boost :: program_options. Cela facilite l'analyse de la ligne de commande.
J'utilise Boost Pointer Containers de préférence à un conteneur STL de shared_ptrs.
J'utilise boost :: numeric :: ublas :: matrix un peu.
J'utilise boost::icl beaucoup pour le post-traitement de texte. Cela m'a fait gagner beaucoup de temps car sinon je devrais implémenter moi-même le fractionnement de texte ...
BOOST_FOREACH est partout dans mon code :)
boost::function et boost::bind sont un must absolu. Bien qu'ils soient maintenant std::function et std::bind. Ceux-ci aident vraiment à réduire la quantité de code inutile et sont généralement bons pour mes conceptions (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 façons natives de faire beaucoup de choses que Boost fait. Si jamais je devais programmer du C++ pur, je suppose que je deviendrais un boost::junkie :)
J'adore boost :: random et boost :: asio et boost :: filesystem, cependant 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 une nouvelle que j'ai trouvée:
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 :: tout
- boost :: variante
- Boost Pointer Container Library (ptr_vector)
- Bibliothèque Boost Pool
- boost :: unordered_map/boost :: unordered_set
Je pense que la question devrait être inversée. Quelle partie de votre boost aimeriez-vous ne pas vouloir 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 à regarder tout autour de la documentation boost pour trouver les domaines qui couvrent vos intérêts.
Une exception peut être boost::numeric::ublas qui fait son travail, mais Eigen le fait remarquablement mieux.
En parlant de boost :: lexical_cast, pourquoi quelque chose comme 'formater' n'est-il pas un membre statique dans la bibliothèque std :: string?
Presque toutes les bibliothèques gui ont quelque chose comme CString :: Format ("% i") ou QString :: Number ("% i") qui retournent une chaîne initialisée.