Como usar o Boost no Visual Studio 2010

Qual é uma boa explicação passo a passo sobre como usar a biblioteca Boost em um projeto vazio no Visual Studio?

Embora a resposta de Nate já seja bastante boa, vou expandi-la mais especificamente para o Visual Studio 2010, conforme solicitado, e incluir informações sobre a compilação nos vários componentes opcionais que requerem bibliotecas externas.

Se você estiver usando apenas bibliotecas de cabeçalhos, tudo o que você precisa fazer é desarquivar o download do impulso e configurar as variáveis ​​de ambiente. As instruções abaixo definem as variáveis ​​de ambiente apenas para o Visual Studio e não em todo o sistema. Observe que você só precisa fazer isso uma vez.

1. Desarquivar a versão mais recente do boost (1.47.0 até o momento da gravação) em um diretório de sua escolha (por exemplo C:\boost_1_47_0).
2. Crie um novo projeto vazio no Visual Studio.
3. Abra o Gerenciador de propriedades e expanda uma das configurações da plataforma de sua escolha.
4. Selecione e clique com o botão direito Microsoft.Cpp.<Platform>.usere selecione Propertiespara abrir a Página de propriedades para edição.
5. Selecione VC++ Directoriesà esquerda.
6. Edite a Include Directoriesseção para incluir o caminho para seus arquivos de origem do impulso.
7. Repita as etapas 3 a 6 para a plataforma diferente de sua escolha, se necessário.

Se você deseja usar a parte do impulso que requer construção, mas nenhum dos recursos que requer dependências externas, a construção é bastante simples.

1. Desarquivar a versão mais recente do boost (1.47.0 até o momento da gravação) em um diretório de sua escolha (por exemplo C:\boost_1_47_0).
2. Inicie o prompt de comando do Visual Studio para a plataforma de sua escolha e navegue até onde está o aumento.
3. Execute: bootstrap.batpara criar o b2.exe (anteriormente chamado bjam).

4. Execute b2:

   • Win32: b2 --toolset=msvc-10.0 --build-type=complete stage ;
   • x64: b2 --toolset=msvc-10.0 --build-type=complete architecture=x86 address-model=64 stage

Faça uma caminhada / assista a um filme ou 2 / ....

8. Siga as etapas 2 a 6 do conjunto de instruções acima para definir as variáveis ​​de ambiente.
9. Edite a Library Directoriesseção para incluir o caminho para a saída das bibliotecas de reforço. (O padrão para o exemplo e as instruções acima seria C:\boost_1_47_0\stage\lib. Renomeie e mova o diretório primeiro se desejar ter x86 e x64 lado a lado (como <BOOST_PATH>\lib\x86& <BOOST_PATH>\lib\x64).
10. Repita as etapas 2 a 6 para a plataforma diferente de sua escolha, se necessário.

Se você deseja os componentes opcionais, tem mais trabalho a fazer. Esses são:

• Filtros Boost.IOStreams Bzip2
• Filtros Boost.IOStreams Zlib
• Boost.MPI
• Boost.Python
• Suporte para Boost.Regex ICU

Filtros Boost.IOStreams Bzip2:

1. Desarquivar a versão mais recente dos arquivos de origem da biblioteca bzip2 (1.0.6 na gravação) em um diretório de sua escolha (por exemplo, C:\bzip2-1.0.6 ).
2. Siga o segundo conjunto de instruções acima para criar o aumento, mas adicione a opção -sBZIP2_SOURCE="C:\bzip2-1.0.6"ao executar b2 na etapa 5.

Filtros Boost.IOStreams Zlib

1. Desarquive a versão mais recente dos arquivos de origem da biblioteca zlib (1.2.5 na gravação) em um diretório de sua escolha (por exemplo C:\zlib-1.2.5).
2. Siga o segundo conjunto de instruções acima para criar o aumento, mas adicione a opção -sZLIB_SOURCE="C:\zlib-1.2.5"ao executar b2 na etapa 5.

Boost.MPI

1. Instale uma distribuição MPI, como o Microsoft Compute Cluster Pack.
2. Siga as etapas 1 a 3 do segundo conjunto de instruções acima para aumentar o impulso.
3. Edite o arquivo project-config.jamno diretório <BOOST_PATH>que resultou da execução do bootstrap. Adicione uma linha que leia using mpi ;(observe o espaço antes do ';').
4. Siga o restante das etapas do segundo conjunto de instruções acima para aumentar o impulso. Se a detecção automática da instalação do MPI falhar, será necessário procurar e modificar o arquivo de compilação apropriado para procurar o MPI no lugar certo.

Boost.Python

1. Instale uma distribuição Python, como o ActivePython do ActiveState. Verifique se a instalação do Python está no seu PATH.

2. Para criar completamente a versão de 32 bits da biblioteca, é necessário Python de 32 bits e da mesma forma para a versão de 64 bits. Se você tiver várias versões instaladas por esse motivo, precisará informar ao b2 onde encontrar uma versão específica e quando usar qual. Uma maneira de fazer isso seria editar o arquivo project-config.jamno diretório <BOOST_PATH>resultante da execução do bootstrap. Adicione as duas linhas a seguir, ajustando conforme apropriado para os caminhos e versões de instalação do Python (observe o espaço antes do ';').

   using python : 2.6 : C:\\Python\\Python26\\python ;

   using python : 2.6 : C:\\Python\\Python26-x64\\python : : : <address-model>64 ;

   Observe que essa especificação explícita do Python atualmente causa falha na compilação do MPI. Portanto, você precisará criar um edifício separado, com e sem especificação, para construir tudo, se estiver criando o MPI também.

3. Siga o segundo conjunto de instruções acima para aumentar o impulso.

Suporte para Boost.Regex ICU

1. Desarquivar a versão mais recente do arquivo de origem da biblioteca ICU4C (4.8 na gravação) em um diretório de sua escolha (por exemplo, C:\icu4c-4_8 ).
2. Abra a solução do Visual Studio em <ICU_PATH>\source\allinone.
3. Construa Tudo para a configuração de depuração e lançamento da plataforma de sua escolha. Pode haver um problema ao criar versões recentes do ICU4C com o Visual Studio 2010 quando a saída para a compilação de depuração e versão estiver no mesmo diretório (que é o comportamento padrão). Uma possível solução alternativa é fazer um Build All (por exemplo, de build de depuração) e, em seguida, fazer o Rebuild all na segunda configuração (por exemplo, release build).
4. Se estiver construindo para x64, será necessário executar o sistema operacional x64, pois há etapas pós-compilação que envolvem a execução de alguns dos aplicativos de 64 bits que estão sendo construídos.
5. Opcionalmente, remova o diretório de origem quando terminar.
6. Siga o segundo conjunto de instruções acima para criar o aumento, mas adicione a opção -sICU_PATH="C:\icu4c-4_8"ao executar b2 na etapa 5.

Embora as instruções no site do Boost sejam úteis, aqui está uma versão condensada que também cria bibliotecas x64.

• Você só precisa fazer isso se estiver usando uma das bibliotecas mencionadas na seção 3 da página de instruções. (Por exemplo, para usar o Boost.Filesystem requer compilação.) Se você não estiver usando nenhum deles, basta descompactar e pronto.

Construir as bibliotecas de 32 bits

Isso instala os arquivos de cabeçalho Boost em C:\Boost\include\boost-(version) e as bibliotecas de 32 bits em C:\Boost\lib\i386. Observe que o local padrão para as bibliotecas é, C:\Boost\libmas você deseja colocá-las em um i386diretório se planeja construir para várias arquiteturas.

1. Descompacte o Boost em um novo diretório.
2. Inicie um prompt de comando do MSVC de 32 bits e mude para o diretório em que o Boost foi descompactado.
3. Corre: bootstrap

4. Corre: b2 toolset=msvc-12.0 --build-type=complete --libdir=C:\Boost\lib\i386 install

   • Para o Visual Studio 2012, use toolset=msvc-11.0
   • Para o Visual Studio 2010, use toolset=msvc-10.0
   • Para o Visual Studio 2017, use toolset=msvc-14.1

5. Adicionar C:\Boost\include\boost-(version) ao seu caminho de inclusão.

6. Adicione C:\Boost\lib\i386ao seu caminho de bibliotecas.

Construa as bibliotecas de 64 bits

Isso instala os arquivos de cabeçalho do Boost em C:\Boost\include\boost-(version)e as bibliotecas de 64 bits em C:\Boost\lib\x64. Observe que o local padrão para as bibliotecas é, C:\Boost\libmas você deseja colocá-las em um x64diretório se planeja construir para várias arquiteturas.

1. Descompacte o Boost em um novo diretório.
2. Inicie um prompt de comando do MSVC de 64 bits e mude para o diretório em que o Boost foi descompactado.
3. Corre: bootstrap
4. Corre: b2 toolset=msvc-12.0 --build-type=complete --libdir=C:\Boost\lib\x64 architecture=x86 address-model=64 install
   • Para o Visual Studio 2012, use toolset=msvc-11.0
   • Para o Visual Studio 2010, use toolset=msvc-10.0
5. AdicioneC:\Boost\include\boost-(version) ao seu caminho de inclusão.
6. Adicione C:\Boost\lib\x64ao seu caminho de bibliotecas.

Você também pode tentar -j% NUMBER_OF_PROCESSORS% como argumento para usar todos os seus núcleos. Torna as coisas super rápidas no meu quad core.

Eu poderia recomendar o seguinte truque: Crie um boost.propsarquivo especial

1. Abra o gerenciador de propriedades
2. Clique com o botão direito do mouse no nó do seu projeto e selecione 'Adicionar nova folha de propriedades do projeto'.
3. Selecione um local e nomeie sua folha de propriedades (por exemplo, c: \ mystuff \ boost.props)
4. Modifique as pastas Incluir e Lib adicionais para o caminho da pesquisa.

Este procedimento tem o valor de que o aumento é incluído apenas em projetos nos quais você deseja incluí-lo explicitamente. Quando você tiver um novo projeto que use boost, faça:

1. Abra o gerenciador de propriedades.
2. Clique com o botão direito do mouse no nó do projeto e selecione 'Adicionar folha de propriedades existente'.
3. Selecione a folha de propriedades do impulso.

EDIT (edição seguinte de @ jim-fred):

O boost.propsarquivo resultante é mais ou menos assim ...

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ImportGroup Label="PropertySheets" />
  <PropertyGroup Label="UserMacros">
    <BOOST_DIR>D:\boost_1_53_0\</BOOST_DIR>
  </PropertyGroup>
  <PropertyGroup>
    <IncludePath>$(BOOST_DIR);$(IncludePath)</IncludePath>
    <LibraryPath>$(BOOST_DIR)stage\lib\;$(LibraryPath)</LibraryPath>
  </PropertyGroup>
</Project>

Ele contém uma macro de usuário para o local do diretório boost (neste caso, D: \ boost_1_53_0) e dois outros parâmetros: IncludePath e LibraryPath. Uma afirmação#include <boost/thread.hpp> encontraria o thread.hpp no ​​diretório apropriado (nesse caso, D: \ boost_1_53_0 \ boost \ thread.hpp). O diretório 'stage \ lib \' pode mudar dependendo do diretório instalado no.

Esse arquivo boost.props pode estar localizado no D:\boost_1_53_0\diretório

Quais partes do Boost você precisa? Muitas coisas fazem parte do TR1, que é enviado com o Visual Studio, então você pode simplesmente dizer, por exemplo:

#include <tr1/memory>

using std::tr1::shared_ptr;

De acordo com James, isso também deve funcionar (em C ++ 0x):

#include <memory>

using std::shared_ptr;

Esse tópico já existe há algum tempo e eu pensei em adicionar algo sobre COMO criar o Boost o mais rápido possível em seu hardware específico.

Se você possui um núcleo de 4 ou 6 núcleos, use -j5 ou -j7, respectivamente. Certamente não é a construção padrão nem -j2, a menos que você realmente tenha um núcleo dual.

Estou executando um Sandy Bridge Extreme com 3930K (6 núcleos) com clock de estoque na minha estação principal, mas tenho uma caixa de backup mais antiga de 2600k (4 núcleos) e a tendência é obter os melhores tempos de compilação do Boost com N + 1 constrói processos em que N é o número de núcleos físicos. N + 2 atinge um ponto de retornos decrescentes e os tempos aumentam.

Notas: O Hyperthreading está ativado, 32 GB de RAM DDR3, SSD Samsung 840 EVO.

-j7 em 6 núcleos (2 minutos e 51 segundos) (Win7 Ultimate x64) (Visual Studio 2013)

PS C:\Boost\boost_1_56_0> measure-command { .\b2 -j7 --build-type=complete msvc stage }

Days              : 0
Hours             : 0
Minutes           : 2
Seconds           : 51
Milliseconds      : 128
Ticks             : 1711281830
TotalDays         : 0.0019806502662037
TotalHours        : 0.0475356063888889
TotalMinutes      : 2.85213638333333
TotalSeconds      : 171.128183
TotalMilliseconds : 171128.183

-j6 em 6 núcleos (3 minutos e 2 segundos) (Win7 Ultimate x64) (Visual Studio 2013)

PS C:\Boost\boost_1_56_0> measure-command { .\b2 -j6 --build-type=complete msvc stage }

Days              : 0
Hours             : 0
Minutes           : 3
Seconds           : 2
Milliseconds      : 809
Ticks             : 1828093904
TotalDays         : 0.00211584942592593
TotalHours        : 0.0507803862222222
TotalMinutes      : 3.04682317333333
TotalSeconds      : 182.8093904
TotalMilliseconds : 182809.3904

-j8 em 6 núcleos (3 minutos e 17 segundos) (Win7 Ultimate x64) (Visual Studio 2013)

PS C:\Boost\boost_1_56_0> measure-command { .\b2 -j8 --build-type=complete msvc stage }

Days              : 0
Hours             : 0
Minutes           : 3
Seconds           : 17
Milliseconds      : 652
Ticks             : 1976523915
TotalDays         : 0.00228764342013889
TotalHours        : 0.0549034420833333
TotalMinutes      : 3.294206525
TotalSeconds      : 197.6523915
TotalMilliseconds : 197652.3915

Config

Building the Boost C++ Libraries.


Performing configuration checks

    - 32-bit                   : yes (cached)
    - arm                      : no  (cached)
    - mips1                    : no  (cached)
    - power                    : no  (cached)
    - sparc                    : no  (cached)
    - x86                      : yes (cached)
    - has_icu builds           : no  (cached)
warning: Graph library does not contain MPI-based parallel components.
note: to enable them, add "using mpi ;" to your user-config.jam
    - zlib                     : no  (cached)
    - iconv (libc)             : no  (cached)
    - iconv (separate)         : no  (cached)
    - icu                      : no  (cached)
    - icu (lib64)              : no  (cached)
    - message-compiler         : yes (cached)
    - compiler-supports-ssse3  : yes (cached)
    - compiler-supports-avx2   : yes (cached)
    - gcc visibility           : no  (cached)
    - long double support      : yes (cached)
warning: skipping optional Message Passing Interface (MPI) library.
note: to enable MPI support, add "using mpi ;" to user-config.jam.
note: to suppress this message, pass "--without-mpi" to bjam.
note: otherwise, you can safely ignore this message.
    - zlib                     : no  (cached)

Observo que a compilação de 64 bits demora um pouco mais, preciso fazer a mesma comparação e atualizar.

Também uma pequena observação: se você deseja reduzir o tempo de compilação, pode adicionar a sinalização

-j2

para executar duas construções paralelas ao mesmo tempo. Isso pode reduzir a exibição de um filme;)

Download boost em: http://www.boost.org/users/download/ por exemplo, por svn

• Windows -> tartaruga (a maneira mais simples)

Depois disso: cmd -> vá para o diretório boost ("D: \ boostTrunk" - onde você faz o checkout ou baixa e extrai o pacote): command: bootstrap

criamos o bjam.exe em ("D: \ boostTrunk") Depois disso: comando: bjam toolset = variante msvc-10.0 = depuração, lançamento threading = multi link = static (isso levará algum tempo ~ 20 minutos).

Depois disso: Abra o Visual studio 2010 -> crie um projeto vazio -> vá para as propriedades do projeto -> defina:

Cole este código e verifique se está funcionando?

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/regex.hpp>

using namespace std;

struct Hello 
{
    Hello(){ 
        cout << "Hello constructor" << endl;
    }

    ~Hello(){
        cout << "Hello destructor" << endl;
        cin.get();
    }
};


int main(int argc, char**argv)
{
    //Boost regex, compiled library
    boost::regex regex("^(Hello|Bye) Boost$");
    boost::cmatch helloMatches;
    boost::regex_search("Hello Boost", helloMatches, regex);
    cout << "The word between () is: " << helloMatches[1] << endl;

    //Boost shared pointer, header only library
    boost::shared_ptr<Hello> sharedHello(new Hello);

    return 0;
}

Recursos: https://www.youtube.com/watch?v=5AmwIwedTCM

Aqui está como eu pude usar o Boost:

1. Faça o download e extraia a versão zip das bibliotecas do Boost.
2. Execute o arquivo bootstrap.bat e execute o bjam.exe.
3. Aguarde aproximadamente 30 minutos ou mais.
4. Crie um novo projeto no Visual Studio.
5. Vá para projeto -> propriedades -> vinculador -> geral -> diretórios adicionais da biblioteca e adicione o diretório boost / stage / lib a ele.
6. Vá para projeto -> propriedades -> C / C ++ -> Geral -> Diretórios de Inclusão Adicionais e inclua o diretório boost .

Você poderá criar seu projeto sem erros!

Os instaladores do Windows localizados aqui funcionaram perfeitamente para mim. Eu tomei as seguintes etapas:

1. Siga o assistente de instalação até terminar.
2. Execute o visual studio.
3. Crie um novo projeto C ++
4. Abrir propriedades do projeto (pode ser encontrado clicando com o botão direito do mouse no nome do projeto no Solution Explorer)
5. Em "C / C ++> Geral> Diretórios de Inclusão Adicionais", adicione o caminho onde o diretório raiz de impulso. O padrão para minha versão era C: \ local \ boost_1_63_0. O número após "impulso" é a versão do impulso.
6. Nas propriedades do projeto, em "Vinculador> Diretórios Adicionais da Biblioteca", adicione o diretório dos arquivos da biblioteca. O padrão para minha versão era C: \ local \ boost_1_63_0 \ lib64-msvc-14.0. O número após "lib" está relacionado ao destino da compilação (32 ou 64 bits no Visual Studio) e o número após "msvc" está relacionado à versão do Visual Studio (14.0 está relacionada ao Visual Studio 2015, mas eu sou usando-o com o Visual Studio 2017).

Boa sorte!

Uma pequena adição à resposta principal muito informativa do KTC:

Se você estiver usando o Visual Studio c ++ 2010 Express gratuito e conseguiu que ele compile binários de 64 bits, e agora deseja usá-lo para usar uma versão de 64 bits das bibliotecas do Boost, você pode acabar com 32 bibliotecas de bits (sua milhagem pode variar, é claro, mas na minha máquina esse é o caso triste).

Eu poderia corrigir isso usando o seguinte: entre as etapas descritas acima como

1. Inicie um prompt de comando do MSVC de 32 bits e mude para o diretório em que o Boost foi descompactado.
2. Executar: bootstrap

Inseri uma chamada para 'setenv' para definir o ambiente. Para uma versão compilada, as etapas acima se tornam:

1. Inicie um prompt de comando do MSVC de 32 bits e mude para o diretório em que o Boost foi descompactado.
2. Execute: "C: \ Arquivos de Programas \ Microsoft SDKs \ Windows \ v7.1 \ Bin \ setenv.cmd" / Release / x64
3. Executar: bootstrap

Encontrei essas informações aqui: http://boost.2283326.n4.nabble.com/64-bit-with-VS-Express-again-td3044258.html

Um exemplo minimalista para você começar no Visual Studio:

1. Download e descompacte o Boost a partir daqui.

2.Crie um projeto vazio do Visual Studio, usando uma biblioteca de exemplo de reforço que não exija compilação separada:

#include <iostream>
#include <boost/format.hpp>

using namespace std;  
using namespace boost;  

int main()  
{  
    unsigned int arr[5] = { 0x05, 0x04, 0xAA, 0x0F, 0x0D };  

    cout << format("%02X-%02X-%02X-%02X-%02X")  
            % arr[0]  
            % arr[1]  
            % arr[2]  
            % arr[3]  
            % arr[4]  
         << endl;  
}  

3. Nas propriedades do projeto do Visual Studio, defina os Diretórios de Inclusão Adicionais:

Para um exemplo muito simples:

Como instalar as bibliotecas de impulso no Visual Studio

Se você não quiser usar a biblioteca de impulso inteira, apenas um subconjunto:

Usando um subconjunto das bibliotecas de reforço no Windows

Se você deseja especificamente agora as bibliotecas que exigem compilação:

Como usar as bibliotecas compiladas Boost no Windows

Além disso, há algo que acho muito útil. Use variáveis ​​de ambiente para seus caminhos de impulso. (Como definir variáveis ​​de ambiente no Windows, vincule na parte inferior por 7,8,10) A variável BOOST_ROOT parece ser mais um local comum e é definida como o caminho raiz no qual você descompacta o impulso.

Em Propriedades, c ++, general, Diretórios de Inclusão Adicionais usam $(BOOST_ROOT) . Então, se / quando você mudar para uma versão mais recente da biblioteca de reforço, poderá atualizar sua variável de ambiente para apontar para esta versão mais recente. À medida que mais de seus projetos, use boost, você não precisará atualizar os 'Diretórios de Inclusão Adicionais' para todos eles.

Você também pode criar uma variável BOOST_LIB e apontar para onde as bibliotecas são preparadas. Da mesma forma, para o Linker-> Diretórios Adicionais da Biblioteca, você não precisará atualizar os projetos. Eu tenho algumas coisas antigas construídas com o vs10 e coisas novas com o vs14, então criei os dois sabores da lib boost na mesma pasta. Portanto, se eu mover um projeto do vs10 para o vs14, não preciso alterar os caminhos do impulso.

NOTA: Se você alterar uma variável de ambiente, ela não funcionará repentinamente em um projeto VS aberto. O VS carrega variáveis ​​na inicialização. Então você terá que fechar o VS e reabri-lo.