Partes mais usadas do Boost [fechado]

Quando descobri boost::lexical_cast, pensei comigo mesmo "por que não soube disso antes!" - Eu odiava ter que escrever código como

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

Agora eu escrevo

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

Ontem, no stackoverflow, me deparei com boost split (outra gema que me salvará de escrever 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

Vou começar a procurar na documentação do boost procurando outras funções que poderei usar regularmente, mas acho que será muito fácil perder coisas.

Quais funções de impulso você mais usa / odiaria não ter?

Provavelmente, a parte mais usada do boost para mim é boost :: shared_ptr .

BOOST_FOREACH faz a vida valer a pena novamente.

(Por que ninguém mencionou isso? A pergunta foi feita há 8 meses!)

Meus favoritos são, em nenhuma ordem particular:

• regex
• sistema de arquivo
• fio
• lexical_cast
• program_options (simplesmente brilhante!)
• teste (para todas as minhas necessidades de teste de unidade).
• Algoritmos de string
• Tokenizador de string
• formato (formatação de string de estilo printf de tipo seguro)
• ptrs inteligentes

O Boost foi de grande ajuda quando escrevi meu primeiro aplicativo multiplataforma - sem ele eu realmente teria lutado.

Eu gosto de como você pode fornecer seu próprio destruidor para shared_ptr.
Isso significa, por exemplo, que você pode usá-lo com FILE*e fazer com que ele feche o arquivo para você.
por exemplo

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

Ninguém mencionou os Contêineres de Índice Múltiplo, então irei gritar tarde. Não é tão frequente que você precise deles, mas sem impulso é muito difícil criar uma estrutura de dados equivalente, além de ser menos eficiente. Eu tenho usado muito recentemente para criar contêineres que pesquisam 2 chaves.

Estou surpreso que ninguém tenha mencionado boost::optional. Eu me pego usando com mais frequência do que qualquer parte do Boost, exceto shared_ptre scoped_ptr.

Ninguém menciona boost :: tuple? Por vergonha!

BOOST_STATIC_ASSERT

Atualização (outubro de 2011): C ++ 11 (C ++ 0x) tem static_assert http://www2.research.att.com/~bs/C++0xFAQ.html#static_assert

Um dos meus mais usados ​​não é o Boost propriamente dito, mas o Adobe Source Libraries (ASL) construídas sobre o Boost - especificamente, as extensões dos algoritmos padrão que aceitam boost :: range no lugar de iteradores de início / fim separados. Então, em vez de ligar, diga,

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

Posso simplesmente dizer

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

(Espero que essas partes do ASL migrem para o Boost eventualmente.)

Eu uso muito:

• impulsionar :: sinais
• boost :: shared_ptr
• boost :: lexical_cast
• boost :: bind
• boost :: random
• boost :: thread
• boost :: não copiável

Outros como Tuple, Static Assert e Integer são muito úteis se você estiver escrevendo uma biblioteca que será usada em uma variedade de plataformas.

Coisas como Graphs e Lambda são mais específicas.

boost::shared_ptré um requisito para IMHO de programação C ++ moderno. É por isso que o adicionaram ao padrão com TR1. boost::program_options,, boost::binde boost::signalsão muito legais se você souber para que servem e como usá-los. Os dois últimos tendem a assustar os recém-chegados.

Achamos o boost :: spirit muito útil para uma solução de negócios para analisar ECMAScript. Complexo, mas muito bom!

Estou surpreso por não ver ainda entre as respostas Boost.Thread .

Eu uso o shared_ptr há anos. É tão útil que não há razão para que um projeto fique sem ele.

Além disso, também uso Bind / Function / Lambda para mecanismos de retorno de chamada genéricos - especialmente úteis ao testar - bem como Formato para minha substituição de sprintf de uso geral.

Finalmente, foi outro dia quando usei Variant com raiva para resolver um problema (um analisador que poderia responder com um pequeno conjunto fixo de tipos de tokens não relacionados). A solução foi muito elegante e estou muito feliz com ela.

Anos se passaram e os tempos mudaram, então é hora de uma atualização. SharedPtr e Function agora fazem parte do Standard, e Bind e Lambda são obsoletos pela funcionalidade lambda real em nível de linguagem.

Eu ainda uso o Variant (que também foi padronizado, mas não estou lá ainda), Format foi amplamente substituído por fmtlib (que também foi padronizado).

A grande parte do Boost que uso é o Boost.Asio. Que está em processo de padronização.

Usando tuplas para iterar um mapa, assim:

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

Usando atribuição de impulso, posso inicializar um mapa como este:

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

E usando adaptadores de alcance e o operador de tubo ("|"), posso iterar de trás para frente nos valores de um mapa (como exemplo):

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

Você deve verificar boost :: program_options. Isso torna a análise da linha de comando muito mais fácil.

Eu uso Boost Pointer Containers em vez de um contêiner STL de shared_ptrs.

Eu uso boost :: numeric :: ublas :: matrix um pouco.

Eu adoro boost :: random and boost :: asio e boost :: filesystem, no entanto boost :: bind, boost :: circular_buffer e boost :: thread são muito práticos, ponteiros inteligentes estão ok, mas eu prefiro RAII em vez de gerenciamento de memória

Ok, aqui está um novo que descobri: em
vez de usar stricmp , posso usar a função equals de boost e passar o predicado is_iequal,
por exemplo: em
vez de

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

Eu posso usar

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

dado:

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

Aqui estão meus dois centavos:

• boost :: scope_exit - não há necessidade de definir a classe RAII apenas para um uso
• boost :: any
• boost :: variant
• Boost Pointer Container Library (ptr_vector)
• Biblioteca Boost Pool
• boost :: unordered_map / boost :: unordered_set

eu uso boost::icl bastante para pós-processamento de texto. Economizei muito tempo porque, do contrário, eu mesmo teria que implementar a divisão de texto ...

BOOST_FOREACH está em todo lugar no meu código :)

boost::functione boost::bindsão uma necessidade absoluta. Embora agora eles sejam std::functionestd::bind . Isso realmente ajuda a reduzir a quantidade de código desnecessário e geralmente é bom para meus projetos (ou minhas ilusões).

Recentemente comecei a usar boost::interprocess::message_queue e esta é uma ótima ferramenta também.

Eu usaria muito mais, mas o Qt tem maneiras nativas de fazer muitas coisas que o Boost faz. Se algum dia eu tiver que programar C ++ puro, acho que me tornaria um boost::junkie:)

O que eu mais uso agora está disponível no TR1:

• dicas compartilhadas
• classe de array

Agora eu também uso classes de pool e algumas outras coisas mais específicas.

Você entende agora que Boost se destina a ser útil para a maioria dos programadores, é por isso que é a base de teste para a futura biblioteca padrão.

Falando sobre boost :: lexical_cast, por que algo como 'format' não é um membro estático na biblioteca std :: string?
Quase todos os gui libs têm algo como CString :: Format ("% i") ou QString :: Number ("% i") que retorna uma string inicializada.

Acho que a questão deve ser revertida. Qual parte de seu impulso você não gostaria de usar?

Em minha experiência, praticamente tudo isso é interessante e útil em cada domínio de problema.

Você deve passar um tempo examinando toda a documentação do boost para encontrar as áreas que cobrem seus interesses.

Uma exceção pode ser boost::numeric::ublasque faz seu trabalho, mas Eigen o faz muito melhor.