Come utilizzare Boost in Visual Studio 2010

Qual è una buona spiegazione dettagliata su come utilizzare la libreria Boost in un progetto vuoto in Visual Studio?

Mentre la risposta di Nate è già abbastanza buona, ho intenzione di ampliarla in modo più specifico per Visual Studio 2010 come richiesto, e includerò informazioni sulla compilazione nei vari componenti opzionali che richiedono librerie esterne.

Se si utilizzano solo librerie di intestazioni, è sufficiente annullare l'archiviazione del download boost e impostare le variabili di ambiente. Le istruzioni seguenti impostano le variabili di ambiente solo per Visual Studio e non nell'intero sistema. Nota che devi farlo solo una volta.

1. Annulla l'archiviazione dell'ultima versione di boost (1.47.0 al momento della scrittura) in una directory di tua scelta (ad es C:\boost_1_47_0.).
2. Crea un nuovo progetto vuoto in Visual Studio.
3. Apri il Gestore proprietà ed espandi una delle configurazioni per la piattaforma che preferisci.
4. Selezionare e fare clic con il tasto destro Microsoft.Cpp.<Platform>.user, quindi selezionare Propertiesper aprire la Pagina delle proprietà per la modifica.
5. Seleziona VC++ Directoriesa sinistra.
6. Modifica la Include Directoriessezione per includere il percorso dei tuoi file sorgente boost.
7. Ripetere i passaggi da 3 a 6 per piattaforme diverse a scelta, se necessario.

Se si desidera utilizzare la parte di boost che richiede la creazione, ma nessuna delle funzionalità che richiede dipendenze esterne, la costruzione è abbastanza semplice.

1. Annulla l'archiviazione dell'ultima versione di boost (1.47.0 al momento della scrittura) in una directory di tua scelta (ad es C:\boost_1_47_0.).
2. Avvia il prompt dei comandi di Visual Studio per la piattaforma che preferisci e vai dove si trova boost.
3. Esegui: bootstrap.batper creare b2.exe (precedentemente denominato bjam).

4. Esegui 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

Fai una passeggiata / guarda un film o 2 / ....

8. Eseguire i passaggi da 2 a 6 dall'insieme di istruzioni sopra per impostare le variabili di ambiente.
9. Modifica la Library Directoriessezione per includere il percorso dell'output delle librerie boost. (L'impostazione predefinita per l'esempio e le istruzioni precedenti sarebbe C:\boost_1_47_0\stage\lib. Rinominare e spostare prima la directory se si desidera avere x86 e x64 fianco a fianco (come in <BOOST_PATH>\lib\x86& <BOOST_PATH>\lib\x64).
10. Ripetere i passaggi da 2 a 6 per piattaforme diverse a scelta, se necessario.

Se vuoi i componenti opzionali, allora hai più lavoro da fare. Questi sono:

• Boost.IOS Trasmette filtri Bzip2
• Boost.IOS Trasmette i filtri Zlib
• Boost.MPI
• Boost.Python
• Boost.Regex ICU support

Boost.IOStreams filtri Bzip2:

1. Annulla l'archiviazione dell'ultima versione dei file sorgente della libreria bzip2 (1.0.6 al momento della scrittura) in una directory di tua scelta (ad es C:\bzip2-1.0.6.).
2. Segui la seconda serie di istruzioni sopra per creare boost, ma aggiungi l'opzione -sBZIP2_SOURCE="C:\bzip2-1.0.6"quando esegui b2 nel passaggio 5.

Boost.IOS Trasmette i filtri Zlib

1. Annulla l'archiviazione dell'ultima versione dei file sorgente della libreria zlib (1.2.5 al momento della scrittura) in una directory di tua scelta (ad es C:\zlib-1.2.5.).
2. Segui la seconda serie di istruzioni sopra per creare boost, ma aggiungi l'opzione -sZLIB_SOURCE="C:\zlib-1.2.5"quando esegui b2 nel passaggio 5.

Boost.MPI

1. Installa una distribuzione MPI come Microsoft Compute Cluster Pack.
2. Seguire i passaggi 1 - 3 della seconda serie di istruzioni sopra per creare boost.
3. Modifica il file project-config.jamnella directory <BOOST_PATH>risultante dall'esecuzione di bootstrap. Aggiungi una riga che legge using mpi ;(nota lo spazio prima del ';').
4. Seguire il resto dei passaggi dalla seconda serie di istruzioni sopra per creare boost. Se il rilevamento automatico dell'installazione di MPI non riesce, dovrai cercare e modificare il file di build appropriato per cercare MPI nel posto giusto.

Boost.Python

1. Installa una distribuzione Python come ActivePython di ActiveState. Assicurati che l'installazione di Python sia nel tuo PERCORSO.

2. Per creare completamente la versione a 32 bit della libreria è necessario Python a 32 bit, e allo stesso modo per la versione a 64 bit. Se hai installato più versioni per tale motivo, dovrai dire a b2 dove trovare la versione specifica e quando usare quale. Un modo per farlo sarebbe quello di modificare il file project-config.jamnella directory <BOOST_PATH>risultante dall'esecuzione di bootstrap. Aggiungi le seguenti due righe regolando in modo appropriato per i percorsi e le versioni di installazione di Python (nota lo spazio prima di ';').

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

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

   Si noti che tale specifica esplicita di Python attualmente causa il fallimento della compilazione MPI. Quindi dovrai costruire un edificio separato con e senza specifiche per costruire tutto se stai costruendo anche MPI.

3. Seguire la seconda serie di istruzioni sopra per creare boost.

Boost.Regex ICU support

1. Annulla l'archiviazione dell'ultima versione del file sorgente della libreria ICU4C (4.8 al momento della scrittura) in una directory di tua scelta (ad es C:\icu4c-4_8.).
2. Apri la soluzione Visual Studio in <ICU_PATH>\source\allinone.
3. Crea tutto per la configurazione del debug e del rilascio per la piattaforma che preferisci. Potrebbe essersi verificato un problema durante la creazione di versioni recenti di ICU4C con Visual Studio 2010 quando l'output sia per il debug che per la versione di rilascio si trova nella stessa directory (che è il comportamento predefinito). Una possibile soluzione alternativa è eseguire un Build All (ad esempio build di debug) e quindi eseguire Rebuild all nella seconda configurazione (ad esempio, build di rilascio).
4. Se costruisci per x64, dovrai eseguire il sistema operativo x64 poiché ci sono passaggi post build che comportano l'esecuzione di alcune delle applicazioni a 64 bit che sta costruendo.
5. Facoltativamente, rimuovere la directory di origine al termine.
6. Segui la seconda serie di istruzioni sopra per creare boost, ma aggiungi l'opzione -sICU_PATH="C:\icu4c-4_8"quando esegui b2 nel passaggio 5.

Mentre le istruzioni sul sito Web Boost sono utili, ecco una versione ridotta che crea anche librerie x64.

• Devi farlo solo se stai usando una delle librerie menzionate nella sezione 3 della pagina delle istruzioni. (Ad esempio, per utilizzare Boost.Filesystem è necessaria la compilazione.) Se non si utilizza nessuno di questi, basta decomprimere e andare.

Costruisci le librerie a 32 bit

Ciò installa i file di intestazione Boost in C:\Boost\include\boost-(version)e le librerie a 32 bit in C:\Boost\lib\i386. Si noti che il percorso predefinito per le librerie è C:\Boost\libma è consigliabile inserirle in una i386directory se si prevede di creare per più architetture.

1. Decomprimi Boost in una nuova directory.
2. Avviare un prompt dei comandi MSVC a 32 bit e passare alla directory in cui Boost era decompresso.
3. Correre: bootstrap

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

   • Per Visual Studio 2012, utilizzare toolset=msvc-11.0
   • Per Visual Studio 2010, utilizzare toolset=msvc-10.0
   • Per Visual Studio 2017, utilizzare toolset=msvc-14.1

5. Aggiungi C:\Boost\include\boost-(version)al tuo percorso di inclusione.

6. Aggiungi C:\Boost\lib\i386al tuo percorso libs.

Costruisci le librerie a 64 bit

Ciò installa i file di intestazione Boost in C:\Boost\include\boost-(version)e le librerie a 64 bit in C:\Boost\lib\x64. Si noti che il percorso predefinito per le librerie è C:\Boost\libma è consigliabile inserirle in una x64directory se si prevede di creare per più architetture.

1. Decomprimi Boost in una nuova directory.
2. Avviare un prompt dei comandi MSVC a 64 bit e passare alla directory in cui Boost è stato decompresso.
3. Correre: bootstrap
4. Correre: b2 toolset=msvc-12.0 --build-type=complete --libdir=C:\Boost\lib\x64 architecture=x86 address-model=64 install
   • Per Visual Studio 2012, utilizzare toolset=msvc-11.0
   • Per Visual Studio 2010, utilizzare toolset=msvc-10.0
5. Aggiungi C:\Boost\include\boost-(version)al tuo percorso di inclusione.
6. Aggiungi C:\Boost\lib\x64al tuo percorso libs.

Puoi anche provare -j% NUMBER_OF_PROCESSORS% come argomento che utilizzerà tutti i tuoi core. Rende le cose super veloci sul mio quad core.

Potrei raccomandare il seguente trucco: creare un boost.propsfile speciale

1. Apri il gestore della proprietà
2. Fare clic con il tasto destro sul nodo del progetto e selezionare "Aggiungi nuova finestra delle proprietà del progetto".
3. Seleziona una posizione e assegna un nome alla finestra delle proprietà (ad es. C: \ mystuff \ boost.props)
4. Modifica le cartelle Includi e Lib aggiuntive nel percorso di ricerca.

Questa procedura ha il valore che boost è incluso solo nei progetti in cui si desidera includerlo esplicitamente. Quando hai un nuovo progetto che utilizza boost, esegui:

1. Apri il gestore della proprietà.
2. Fare clic con il tasto destro sul nodo del progetto e selezionare 'Aggiungi foglio delle proprietà esistente'.
3. Seleziona la finestra delle proprietà di boost.

EDIT (seguente modifica da @ jim-fred):

Il boost.propsfile risultante è simile al seguente ...

<?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>

Contiene una macro utente per l'ubicazione della directory boost (in questo caso, D: \ boost_1_53_0) e altri due parametri: IncludePath e LibraryPath. Una dichiarazione #include <boost/thread.hpp>troverebbe thread.hpp nella directory appropriata (in questo caso, D: \ boost_1_53_0 \ spinta \ thread.hpp). La directory 'stage \ lib \' può cambiare a seconda della directory installata in.

Questo file boost.props potrebbe trovarsi nella D:\boost_1_53_0\directory.

Di quali parti di Boost hai bisogno? Molte cose fanno parte di TR1 che viene fornito con Visual Studio, quindi si potrebbe semplicemente dire, ad esempio:

#include <tr1/memory>

using std::tr1::shared_ptr;

Secondo James, anche questo dovrebbe funzionare (in C ++ 0x):

#include <memory>

using std::shared_ptr;

Questo thread è in corso da un po 'di tempo e ho pensato di aggiungere qualcosa su COME costruire Boost il più velocemente possibile sul tuo hardware specifico.

Se hai un 4 o 6 core usa rispettivamente -j5 o -j7. Certamente non la build standard né -j2 a meno che tu non abbia effettivamente un dual core.

Sto eseguendo un Sandy Bridge Extreme con 3930K (6 core) con clock di serie sulla mia stazione principale, ma ho 2600k (4 core) su una scatola di backup precedente e la tendenza è che ottengo i migliori tempi di compilazione Boost con N + 1 processi di compilazione in cui N è il numero di core fisici. N + 2 raggiunge un punto di rendimenti decrescenti e i tempi salgono.

Note: Hyperthreading è abilitato, DDR3 RAM da 32 GB, SSD Samsung 840 EVO.

-j7 su 6 core (2 minuti e 51 secondi) (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 su 6 core (3 minuti e 2 secondi) (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 su 6 core (3 minuti e 17 secondi) (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)

Prendo atto che la compilazione a 64 bit richiede un po 'più di tempo, ho bisogno di fare lo stesso confronto per quelli e aggiornare.

Anche una piccola nota: se si desidera ridurre i tempi di compilazione, è possibile aggiungere il flag

-j2

per eseguire due build parallele contemporaneamente. Ciò potrebbe ridurlo alla visualizzazione di un film;)

Scarica boost da: http://www.boost.org/users/download/ ad es. Di svn

• Windows -> tartaruga (il modo più semplice)

Dopodiché: cmd -> vai alla directory boost ("D: \ boostTrunk" - dove fai il checkout o scarica ed estrai il pacchetto): comando: bootstrap

abbiamo creato bjam.exe in ("D: \ boostTrunk") Dopodiché: comando: bjam toolset = variante msvc-10.0 = debug, rilascio threading = multi link = statico (ci vorrà del tempo ~ 20min.)

Successivamente: Apri Visual Studio 2010 -> crea progetto vuoto -> vai alle proprietà del progetto -> imposta:

Incollare questo codice e verificare se funziona?

#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;
}

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

Ecco come sono stato in grado di utilizzare Boost:

1. Scarica ed estrai la versione zip delle librerie Boost.
2. Eseguire il file bootstrap.bat e quindi eseguire bjam.exe.
3. Attendere circa 30 minuti circa.
4. Crea un nuovo progetto in Visual Studio.
5. Vai al progetto -> proprietà -> Linker -> Generale -> Directory librerie aggiuntive e aggiungi la directory boost / stage / lib .
6. Vai al progetto -> proprietà -> C / C ++ -> Generale -> Directory di inclusione aggiuntive e aggiungi la directory boost ad essa.

Sarai in grado di costruire il tuo progetto senza errori!

Gli installatori di Windows che si trovano qui hanno funzionato perfettamente per me. Ho preso i seguenti passaggi:

1. Seguire la procedura guidata di installazione fino al termine.
2. Esegui Visual Studio.
3. Crea un nuovo progetto C ++
4. Apri le proprietà del progetto (è possibile fare clic con il pulsante destro del mouse sul nome del progetto in Esplora soluzioni)
5. In "C / C ++> Generale> Directory di inclusione aggiuntive" aggiungi il percorso in cui aumentare la directory principale. L'impostazione predefinita per la mia versione era C: \ local \ boost_1_63_0. Il numero dopo "boost" è la versione di boost.
6. Nelle proprietà del progetto, in "Linker> Directory librerie aggiuntive" aggiungi la directory per i file della libreria. L'impostazione predefinita per la mia versione era C: \ local \ boost_1_63_0 \ lib64-msvc-14.0. Il numero dopo "lib" è correlato al target di compilazione (32 bit o 64 bit in Visual Studio) e il numero dopo "msvc" è correlato alla versione di Visual Studio (14.0 è correlato a Visual Studio 2015, ma sono utilizzandolo con Visual Studio 2017).

In bocca al lupo!

Una piccola aggiunta alla risposta principale molto istruttiva di KTC:

Se stai usando Visual Studio c ++ 2010 Express gratuito e sei riuscito a farlo compilare binari a 64 bit e ora vuoi usarlo per usare una versione a 64 bit delle librerie Boost, potresti finire con 32- librerie di bit (il tuo chilometraggio può variare ovviamente, ma sulla mia macchina questo è il caso triste).

Potrei risolvere questo usando quanto segue: tra i passaggi sopra descritti come

1. Avviare un prompt dei comandi MSVC a 32 bit e passare alla directory in cui Boost era decompresso.
2. Esegui: bootstrap

Ho inserito una chiamata a 'setenv' per impostare l'ambiente. Per una build di rilascio, i passaggi precedenti diventano:

1. Avviare un prompt dei comandi MSVC a 32 bit e passare alla directory in cui Boost era decompresso.
2. Esegui: "C: \ Programmi \ Microsoft SDKs \ Windows \ v7.1 \ Bin \ setenv.cmd" / Release / x64
3. Esegui: bootstrap

Ho trovato queste informazioni qui: http://boost.2283326.n4.nabble.com/64-bit-with-VS-Express-again-td3044258.html

Un esempio minimalista per iniziare in Visual Studio:

1. Scarica e decomprimi Boost da qui.

2. Creare un progetto vuoto di Visual Studio, utilizzando una libreria boost di esempio che non richiede una compilazione separata:

#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. Nelle proprietà del progetto Visual Studio impostare le Directory di inclusione aggiuntive:

Per un esempio molto semplice:

Come installare le librerie Boost in Visual Studio

Se non si desidera utilizzare l'intera libreria boost, solo un sottoinsieme:

Utilizzo di un sottoinsieme delle librerie boost in Windows

Se vuoi ora specificamente sulle librerie che richiedono la compilazione:

Come utilizzare le librerie compilate Boost in Windows

Inoltre, c'è qualcosa che trovo molto utile. Usa le variabili di ambiente per i tuoi percorsi di potenziamento. (Come impostare le variabili di ambiente in Windows, collegamento in basso per 7,8,10) La variabile BOOST_ROOT sembra essere più un luogo comune ed è impostata sul percorso principale in cui decomprimere boost.

Quindi in Proprietà, c ++, generale, vengono utilizzate le directory di inclusione aggiuntive $(BOOST_ROOT). Quindi se / quando si passa a una versione più recente della libreria boost, è possibile aggiornare la variabile di ambiente in modo che punti a questa versione più recente. Dato che molti dei tuoi progetti, usa boost, non dovrai aggiornare le "Directory di inclusione aggiuntive" per tutti loro.

È inoltre possibile creare una variabile BOOST_LIB e puntarla sul punto in cui vengono messe in scena le librerie. Allo stesso modo per il Linker-> Directory Library aggiuntive, non dovrai aggiornare i progetti. Ho alcune cose vecchie costruite con vs10 e nuove cose con vs14, quindi ho incorporato entrambi i sapori della libreria boost nella stessa cartella. Quindi se sposto un progetto da vs10 a vs14 non devo cambiare i percorsi di boost.

NOTA: se si modifica una variabile di ambiente, non funzionerà improvvisamente in un progetto VS aperto. VS carica le variabili all'avvio. Quindi dovrai chiudere VS e riaprirlo.