nestle libreria library drink descargar bebida c++ boost

c++ - libreria - descargar boost



La mayoría de las partes usadas de Boost (25)

Cuando descubrí boost::lexical_cast , pensé: "¿por qué no supe 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, encontré boost split (otra gema 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

Comenzaré a buscar en la documentación de refuerzo buscando otras funciones que pueda usar regularmente, pero creo que será muy fácil pasar por alto cosas.

¿Qué funciones de impulso utilizas más / detestaría no tener?

Aquí están mis dos centavos:

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

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

En mi experiencia, casi todo es interesante y útil en cada dominio problemático.

Debe dedicar un 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::ublas que hace su trabajo, pero Eigen hace notablemente mejor.

De acuerdo, aquí hay uno nuevo que he encontrado:
En lugar de usar stricmp , puedo usar la función equal de boost y pasar el predicado is_iequal
p.ej:
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;

Deberías verificar boost :: program_options. Hace el análisis de línea de comandos mucho más fácil.

Encontramos boost :: spirit bastante útil para una solución empresarial para analizar ECMAScript. Complejo, pero muy agradable!

Estoy sorprendido de no ver todavía entre las respuestas de Boost.Thread .

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

He estado usando shared_ptr desde hace años. Es tan útil que no hay motivo para que un proyecto esté sin él.

Además de eso, también utilizo Bind / Function / Lambda para los mecanismos de devolución de llamada genéricos, especialmente útiles para las pruebas, así como para el formato para mi reemplazo sprintf de propósito general.

Finalmente, fue el otro día cuando utilicé Variant en cólera para resolver un problema (un analizador sintáctico que podría responder con un pequeño conjunto fijo de tipos de token no relacionados). La solución fue muy elegante, y estoy muy feliz con eso.

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

  • punteros compartidos
  • clase de matriz

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

Ahora comprende que el impulso debe ser útil para la mayoría de los programadores, por eso es el banco de pruebas para futuras bibliotecas estándar.

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 en cambio como gestión de memoria

Me gusta cómo puedes suministrar tu propio destructor para 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" ); }

Me sorprende que nadie haya mencionado boost::optional . Me encuentro utilizándolo más a menudo que cualquier parte de Boost excepto shared_ptr y scoped_ptr .

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

  • regex
  • filesystem
  • hilo
  • lexical_cast
  • program_options (simplemente genial!)
  • prueba (para todas las necesidades de prueba de mi unidad).
  • Algoritmos de cadena
  • Tokenizador de cadenas
  • formato (formato de cadena de estilo de impresión de tipo seguro)
  • ptrs inteligentes

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

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

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

Uno de los más utilizados no está en Boost propiamente dicho, sino en Adobe Source Libraries (ASL) construido sobre Boost, específicamente las extensiones de los algoritmos estándar que aceptan un rango boost :: en lugar de iteradores de inicio / final separados. Entonces, en lugar de llamar, decir,

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 a Boost eventualmente).

Usando tuplas para iterar un mapa, así:

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

Utilizando boost assign, puedo inicializar un mapa como este:

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

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

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

Uso boost :: icl bastante para postprocesamiento de texto. Me ahorró mucho 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 :: function y boost :: bind son una necesidad absoluta. Aunque ahora son std :: function y std :: bind. Estos realmente ayudan a reducir la cantidad de código innecesario y son generalmente buenos para mis diseños (o mis ilusiones).

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

Usaría mucho más, pero Qt tiene formas nativas de hacer muchas cosas que aumentan. Si alguna vez tengo que programar pure c ++ creo que me convertiría en boost :: yonkie :)

Yo uso Boost Pointer Containers con preferencia a un contenedor STL de shared_ptr s.

Yo uso mucho:

  • boost :: señales
  • boost :: shared_ptr
  • boost :: lexical_cast
  • boost :: bind
  • impulso :: al azar
  • boost :: hilo
  • boost :: noncopyable

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_FOREACH hace que la vida valga la pena nuevamente.

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

boost::shared_ptr es un requisito para la moderna programación C ++ en mi humilde opinión. Es por eso que lo agregaron al estándar con TR1. boost::program_options , boost::bind , y boost::signal son muy buenos si sabes para qué sirven y cómo usarlos. Sin embargo, los dos últimos tienden a asustar a los recién llegados.