Partes mais usadas do Boost [fechado]

115

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?

Hamishmcn
fonte
1
Sem interesse, o que o impediu de escrever sua própria função "converter número em string" antes de usar o Boost? Eu teria visto a duplicação e escrito um modelo simples e usado e então, talvez, mudado para a versão boost quando a encontrei ...
Len Holgate
4
Olá, Len, Em momentos diferentes em projetos diferentes, escrevi uma função "ToStr" com modelo, mas depois passaria para outro projeto e acabaria escrevendo o 3-liner porque só queria terminar o trabalho: - ) em oposição à sobrecarga de criação de um arquivo "misc_funcs"
hamishmcn

Respostas:

62

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

fhe
fonte
13
Também provavelmente mais usado. Eu mesmo aprendi a lição da maneira mais difícil, tendo que refatorar a maioria dos usos de shared_ptr por referências, recipientes de ponteiro e auto_ptr. Agora eu concordo principalmente com isso: bureau14.fr/blogea/index.php/2009/08/…
amit
1
@phaedrus: Link atualizado: blogea.bureau14.fr/index.php/2009/08/…
MatthewD
4
Não é mais relevante no C ++ 11 que tem std::shared_ptre std::unique_ptr.
einpoklum
49

BOOST_FOREACH faz a vida valer a pena novamente.

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

Paul Biggar
fonte
15
O artigo de Eric Niebler sobre "Amor condicional" ( artima.com/cppsource/foreach.html ) descreve como BOOST_FOREACH funciona. É muito louco.
Jeff Hardy
2
Não é mais tão popular com C ++ 11 e lambdas ...
einpoklum
34

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.

Roubar
fonte
4
Atualize para C ++ 11 / C ++ 14 ...
einpoklum
28

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" );
}
Hamishmcn
fonte
1
Eu sei que já se passaram quase dois anos, mas ... essa atribuição a NULLé inútil, pois atribui o parâmetro da função local. :)
Xeo de
1
Obrigado @Xeo, removi-o
hamishmcn
22

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.

Greg Rogers
fonte
20

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.

Head Geek
fonte
1
Agora disponível em std::experimental::optionalbreve (C ++ 17?) Como std::optional.
einpoklum
1
Sim, e estou muito feliz com isso. :-) Embora considerando o atraso entre os padrões e a implementação completa deles em todos os compiladores que uso, ainda vai demorar um pouco antes que eu possa confiar nisso ... Eu acabei de começar a usar C ++ 11 em um projeto no ano passado. :-(
Head Geek
Na verdade, eu acho que a maioria dos compiladores está ok em atender aos padrões nos últimos anos - GCC e clang suportavam C ++ 14 quando foi lançado, não é? De qualquer forma, considere integrar seu comentário em sua resposta.
einpoklum
@HeadGeek Interessante ver um novo comentário adicionado à sua resposta após 8 anos, e você respondeu!
Deqing de
Uau ... acho que já se passaram oito anos. Como diz Caco, o Sapo, é divertido quando você está tendo moscas. ;-)
Head Geek de
19

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


fonte
2
Agora disponível como std::tuple.
Dmitri Nesteruk
11

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

Alessandro Jacopson
fonte
5
BOOST_MPL_ASSERT_MSG permite uma leitura / localização muito fácil de erros que são muito mais informativos do que o tamanho da mensagem do tipo incompleto que BOOST_STATIC_ASSERT fornece.
KitsuneYMG,
aqui aqui! Acabei de encontrar um desses erros de tipo incompleto dentro da macro de teste BOOST_CHECK_CLOSE - levei meio dia para descobrir o que estava acontecendo antes de perceber que o havia chamado com (int, int, float); depois de converter os inteiros para ponto flutuante, o erro foi embora. Mas o que isso tem a ver com um tipo incompleto, eu realmente não sei :)
Jamie Cook
9

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.)

Jon Reid
fonte
Eu gosto, vou dar uma olhada no ASL
hamishmcn
8

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.

Cyrille Ka
fonte
Atualize para estes dias de C ++ 11/14 (ou considere remover a resposta).
einpoklum
8

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.

D.Shawley
fonte
7

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

Kit10
fonte
7

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

Vicente Botet Escriba
fonte
3
Agora existe std::thread.
einpoklum
7

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.

Dragão Kaz
fonte
1
Eu concordo com todas as opções acima - exceto Lambda. Usei por um tempo, mas é tão tortuoso que abandonei tudo, exceto as expressões mais simples. Aguardando ansiosamente C ++ 0x e sua forma de expressões lambda.
Head Geek
Eu concordo que Boost.Lambda está cheio de todos os tipos de armadilhas - assim que eu entro nos reinos de Unlambda ou Protect, eu desisto e faço do jeito antigo, mas parece essencial para estender callbacks de qualquer maneira decente . Dito isso, eu também aguardo a implementação do C ++ 0x.
Kaz Dragon de
6

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) { ... }
Paul Fultz II
fonte
1
Isso é muito legal. Isso me fez ler a documentação para atribuição de impulso: boost.org/doc/libs/1_49_0/libs/assign/doc/index.html
hamishmcn
5

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

Desenvolvedor triste
fonte
5

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

amit
fonte
4

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

Todd Gamblin
fonte
Esta é considerada uma biblioteca desatualizada, eu acho.
Dmitri Nesteruk
3

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

Robert Gould
fonte
6
Os ponteiros inteligentes são RAII.
Eclipse
4
mais precisamente, os ponteiros inteligentes fornecem RAII quando não há escolha a não ser alocar memória dinamicamente.
Branan
3

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;
Hamishmcn
fonte
3

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
anatólia
fonte
3

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:)

Zeks
fonte
3

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.

Klaim
fonte
1

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.

Martin Beckett
fonte
4
por exemplo: std::string = boost::format("Hello, %1% %2%") % "world" % "!!!").str();
Rob
Se você está disposto a abrir mão da segurança de tipo, pode fazer o seu próprio com vsnprintf (), reticências (...), va_list / stdarg.h e um buffer local (baseado em pilha).
Sr.Ree
2
std :: string já tem 71 funções a mais (pela contagem de Herb Sutter, não pela minha). Consulte gotw.ca/gotw/084.htm para obter detalhes: acho que tem informações suficientes para explicar (a) por que o formato não precisa estar em std :: string e (b) por que é melhor escrever algoritmos genéricos do que membros de classe funções de qualquer maneira.
Steve Jessop
4
Ou dito de outra forma, "C ++ é como um país estrangeiro: eles fazem as coisas de forma diferente lá" ;-)
Steve Jessop
1
O formato não faz parte da biblioteca porque um dos desafios que Stroustrup enfrentou ao projetar o C ++ foi a construção de uma biblioteca de E / S formatada com segurança de tipos. Obviamente, o resultado foi o que você vê com iostreams. Aparentemente, ninguém havia pensado em interpolação na época. Talvez alguém queira escrever um Formattream, para fazer os tradicionalistas se sentirem mais em casa?
Phil Miller,
1

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.

Rodrigob
fonte
Duvido que a biblioteca octonion seja usada por muitos.
Petter