Partes más usadas de Boost [cerrado]

Cuando lo descubrí boost::lexical_cast, pensé para mis adentros "¿por qué no me enteré de esto antes?" - Odiaba tener que escribir código como

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

Ahora escribo

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

Ayer, en stackoverflow, me encontré con boost split (otra joya que me ahorrará escribir código).

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

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

Voy a comenzar a revisar la documentación de boost en busca de otras funciones que pueda usar regularmente, pero creo que será muy fácil pasar por alto cosas.

¿Qué funciones de refuerzo usa más / odiaría no tener?

Probablemente la parte más utilizada de boost para mí es boost :: shared_ptr .

BOOST_FOREACH vuelve a hacer que la vida valga la pena.

(¿Por qué nadie ha mencionado esto? ¡La pregunta se hizo hace 8 meses!)

Mis favoritos son, sin ningún orden en particular:

• regex
• sistema de archivos
• hilo
• lexical_cast
• program_options (¡simplemente genial!)
• test (para todas mis necesidades de pruebas unitarias).
• Algoritmos de cadenas
• Tokenizador de cadenas
• formato (formato de cadena de estilo printf con seguridad de tipo)
• ptrs inteligentes

Boost fue una gran ayuda cuando escribí mi primera aplicación multiplataforma; sin ella, realmente habría tenido problemas.

Me gusta cómo puede proporcionar su propio destructor shared_ptr.
Esto significa, por ejemplo, que puede usarlo con FILE*y hacer que cierre el archivo por usted.
p.ej

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

Nadie ha mencionado los contenedores de índices múltiples, así que intervendré más tarde. No es tan frecuente que los necesite, pero sin un impulso es un verdadero dolor crear una estructura de datos equivalente, además de ser menos eficiente. Los he estado usando mucho recientemente para crear contenedores que buscan 2 claves.

Me sorprende que nadie lo haya mencionado boost::optional. Me encuentro usándolo con más frecuencia que cualquier parte de Boost excepto shared_ptry scoped_ptr.

Nadie menciona boost :: tuple? ¡Para vergüenza!

BOOST_STATIC_ASSERT

Actualización (octubre de 2011): C ++ 11 (C ++ 0x) tiene static_assert http://www2.research.att.com/~bs/C++0xFAQ.html#static_assert

Uno de mis más utilizados no es en Boost propiamente dicho, sino en las bibliotecas de origen de Adobe (ASL) creadas sobre Boost, específicamente, las extensiones de los algoritmos estándar que aceptan un boost :: rango en lugar de iteradores de inicio / fin separados. Entonces, en lugar de llamar, di:

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

Simplemente puedo decir

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

(Espero que estas partes de ASL migren eventualmente a Boost).

Yo uso mucho:

• boost :: señales
• boost :: shared_ptr
• boost :: lexical_cast
• boost :: enlazar
• boost :: aleatorio
• boost :: hilo
• impulso :: no copiable

Otros como Tuple, Static Assert y Integer son muy útiles si está escribiendo una biblioteca que se utilizará en una variedad de plataformas.

Cosas como Graphs y Lambda son más específicas.

boost::shared_ptres un requisito para la programación moderna de C ++ en mi humilde opinión. Por eso lo agregaron al estándar con TR1. boost::program_options, boost::bindy boost::signalson realmente agradables si sabes para qué sirven y cómo usarlos. Sin embargo, los dos últimos tienden a asustar a los recién llegados.

Hemos encontrado que boost :: spirit es bastante útil para una solución empresarial para analizar ECMAScript. Complejo, pero muy bonito.

Me sorprende no ver todavía entre las respuestas Boost.Thread .

He estado usando shared_ptr durante años. Es tan útil que no hay razón por la que un proyecto deba estar sin él.

Además de eso, también uso Bind / Function / Lambda para mecanismos de devolución de llamada genéricos, especialmente útiles cuando se realizan pruebas, así como Format para mi reemplazo de sprintf de propósito general.

Finalmente, fue solo el otro día cuando usé Variant con ira para resolver un problema (un analizador que podía responder con un conjunto pequeño y fijo de tipos de tokens no relacionados). La solución fue muy elegante y estoy muy contento con ella.

Han pasado los años y los tiempos han cambiado, así que es hora de actualizar. SharedPtr y Function ahora forman parte del estándar, y Bind y Lambda están obsoletos debido a la funcionalidad lambda real a nivel de lenguaje.

Todavía uso Variant (que también se ha estandarizado, pero aún no he llegado allí), Format se reemplaza en gran medida por fmtlib (que también se ha estandarizado).

La gran parte de Boost que uso es Boost.Asio. Que está en proceso de estandarización.

Usando tuplas para iterar un mapa, como este:

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

Usando boost asignar, puedo inicializar un mapa como este:

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

Y usando adaptadores de rango y el operador de tubería ("|") puedo iterar hacia atrás sobre los valores de un mapa (como ejemplo):

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

Debería comprobar boost :: program_options. Hace que el análisis de la línea de comandos sea mucho más fácil.

Yo uso Boost Pointer Containers en lugar de un contenedor STL de shared_ptrs.

Yo uso bastante boost :: numeric :: ublas :: matrix .

Me encanta boost :: random y boost :: asio y boost :: filesystem, sin embargo boost :: bind, boost :: circular_buffer y boost :: thread son muy prácticos, los punteros inteligentes están bien, pero prefiero RAII como administración de memoria

De acuerdo, aquí hay uno nuevo que encontré: en
lugar de usar stricmp , puedo usar la función igual de boost y pasar el predicado is_iequal,
por ejemplo: en
lugar de

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

Puedo usar

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

dado:

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

Aquí están mis dos centavos:

• boost :: scope_exit - no es necesario definir la clase RAII solo para un uso
• boost :: cualquiera
• impulso :: variante
• Boost Pointer Container Library (ptr_vector)
• Boost Pool Library
• boost :: unordered_map / boost :: unordered_set

Utilizo boost::iclbastante para el posprocesamiento de texto. Me ahorré bastante tiempo porque de lo contrario tendría que implementar la división de texto yo mismo ...

BOOST_FOREACH está en todas partes en mi código :)

boost::functiony boost::bindson una necesidad absoluta. Aunque ahora son std::functiony std::bind. Estos realmente ayudan a reducir la cantidad de código innecesario y generalmente son buenos para mis diseños (o mis delirios).

Recientemente comencé a usar boost::interprocess::message_queuey esta también es una gran herramienta.

Usaría mucho más, pero Qt tiene formas nativas de hacer muchas cosas que hace Boost. Si alguna vez tuviera que programar en C ++ puro, supongo que me convertiría en boost::junkie:)

Lo que más uso ahora está disponible en el TR1:

• punteros compartidos
• clase de matriz

Ahora también uso clases de pool y algunas otras cosas más específicas.

Ahora comprende que Boost está destinado a ser útil para la mayoría de los programadores, por eso es el banco de pruebas para la futura biblioteca estándar.

Hablando de boost :: lexical_cast, ¿por qué algo como 'formato' no es un miembro estático en la biblioteca std :: string?
Casi todas las gui libs tienen algo como CString :: Format ("% i") o QString :: Number ("% i") que devuelven una cadena inicializada.

Creo que la pregunta debería invertirse. ¿Qué parte de ti impulso no querrías? usar?

En mi experiencia, casi todo es interesante y útil en cada dominio del problema.

Debería dedicar tiempo a buscar en toda la documentación de impulso para encontrar las áreas que cubren sus intereses.

Una excepción puede ser boost::numeric::ublascuál hace su trabajo, pero Eigen lo hace notablemente mejor.