Cómo usar Boost en Visual Studio 2010

¿Cuál es una buena explicación paso a paso sobre cómo usar la biblioteca Boost en un proyecto vacío en Visual Studio?

Si bien la respuesta de Nate ya es bastante buena, voy a ampliarla más específicamente para Visual Studio 2010 según lo solicitado, e incluiré información sobre la compilación en los diversos componentes opcionales que requieren bibliotecas externas.

Si está utilizando bibliotecas de encabezados solamente, entonces todo lo que necesita hacer es desarchivar la descarga de impulso y configurar las variables de entorno. Las instrucciones a continuación establecen las variables de entorno solo para Visual Studio, y no en todo el sistema en su conjunto. Tenga en cuenta que solo tiene que hacerlo una vez.

1. Desarchive la última versión de boost (1.47.0 al momento de la escritura) en un directorio de su elección (por ejemplo C:\boost_1_47_0).
2. Cree un nuevo proyecto vacío en Visual Studio.
3. Abra el Administrador de propiedades y expanda una de las configuraciones para la plataforma de su elección.
4. Seleccione y haga clic derecho Microsoft.Cpp.<Platform>.user, y seleccione Propertiespara abrir la Página de propiedades para editar.
5. Seleccione VC++ Directoriesa la izquierda.
6. Edite la Include Directoriessección para incluir la ruta a sus archivos fuente de impulso.
7. Repita los pasos 3 - 6 para diferentes plataformas de su elección si es necesario.

Si desea utilizar la parte de impulso que requiere construcción, pero ninguna de las características que requieren dependencias externas, entonces construirla es bastante simple.

1. Desarchive la última versión de boost (1.47.0 al momento de la escritura) en un directorio de su elección (por ejemplo C:\boost_1_47_0).
2. Inicie el símbolo del sistema de Visual Studio para la plataforma de su elección y navegue hasta donde está el impulso.
3. Ejecutar: bootstrap.batpara compilar b2.exe (anteriormente denominado bjam).

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

Sal a caminar / mira una película o 2 / ....

8. Siga los pasos 2 - 6 del conjunto de instrucciones anterior para configurar las variables de entorno.
9. Edite la Library Directoriessección para incluir la ruta a la salida de sus bibliotecas de impulso. (El valor predeterminado para el ejemplo y las instrucciones anteriores sería C:\boost_1_47_0\stage\lib. Cambie el nombre y mueva el directorio primero si desea tener x86 y x64 uno al lado del otro (como a <BOOST_PATH>\lib\x86& <BOOST_PATH>\lib\x64).
10. Repita los pasos 2 - 6 para diferentes plataformas de su elección si es necesario.

Si desea los componentes opcionales, entonces tiene más trabajo por hacer. Estos son:

• Boost.IOStreams filtros Bzip2
• Boost.IOStreams filtros Zlib
• Boost.MPI
• Boost.Python
• Boost.Regex soporte de UCI

Filtros Boost.IOStreams Bzip2:

1. Desarchive la última versión de los archivos fuente de la biblioteca bzip2 (1.0.6 en el momento de la escritura) en un directorio de su elección (por ejemplo C:\bzip2-1.0.6).
2. Siga el segundo conjunto de instrucciones anteriores para generar impulso, pero agregue la opción -sBZIP2_SOURCE="C:\bzip2-1.0.6"cuando ejecute b2 en el paso 5.

Boost.IOStreams filtros Zlib

1. Desarchive la última versión de los archivos fuente de la biblioteca zlib (1.2.5 en el momento de la escritura) en un directorio de su elección (por ejemplo C:\zlib-1.2.5).
2. Siga el segundo conjunto de instrucciones anteriores para generar impulso, pero agregue la opción -sZLIB_SOURCE="C:\zlib-1.2.5"cuando ejecute b2 en el paso 5.

Boost.MPI

1. Instale una distribución MPI como Microsoft Compute Cluster Pack.
2. Siga los pasos 1 a 3 del segundo conjunto de instrucciones anteriores para generar impulso.
3. Edite el archivo project-config.jamen el directorio <BOOST_PATH>que resultó de ejecutar bootstrap. Agregue una línea que lea using mpi ;(observe el espacio antes de ';').
4. Siga el resto de los pasos del segundo conjunto de instrucciones anteriores para generar impulso. Si la detección automática de la instalación de MPI falla, entonces deberá buscar y modificar el archivo de compilación apropiado para buscar MPI en el lugar correcto.

Boost.Python

1. Instale una distribución de Python como ActivePython de ActiveState. Asegúrese de que la instalación de Python esté en su RUTA.

2. Para construir completamente la versión de 32 bits de la biblioteca se requiere Python de 32 bits, y de manera similar para la versión de 64 bits. Si tiene varias versiones instaladas por ese motivo, deberá decirle a b2 dónde encontrar una versión específica y cuándo usar cuál. Una forma de hacerlo sería editar el archivo project-config.jamen el directorio <BOOST_PATH>que resultó de ejecutar bootstrap. Agregue las siguientes dos líneas ajustando según corresponda para sus rutas y versiones de instalación de Python (tenga en cuenta el espacio antes de ';').

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

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

   Tenga en cuenta que tal especificación explícita de Python actualmente hace que la compilación MPI falle. Por lo tanto, tendrá que hacer una construcción separada con y sin especificación para construir todo si también está creando MPI.

3. Siga el segundo conjunto de instrucciones anteriores para generar impulso.

Boost.Regex soporte de UCI

1. Desarchive la última versión del archivo fuente de la biblioteca ICU4C (4.8 en el momento de la escritura) en un directorio de su elección (por ejemplo C:\icu4c-4_8).
2. Abra la solución de Visual Studio en <ICU_PATH>\source\allinone.
3. Build All para la configuración de depuración y liberación para la plataforma que elija. Puede haber un problema al compilar versiones recientes de ICU4C con Visual Studio 2010 cuando la salida para la compilación de depuración y lanzamiento está en el mismo directorio (que es el comportamiento predeterminado). Una posible solución es hacer un Build All (de depuración build, por ejemplo) y luego reconstruir todo en la segunda configuración (por ejemplo, release build).
4. Si está compilando para x64, deberá ejecutar el sistema operativo x64 ya que hay pasos posteriores a la compilación que implican ejecutar algunas de las aplicaciones de 64 bits que está construyendo.
5. Opcionalmente, elimine el directorio de origen cuando haya terminado.
6. Siga el segundo conjunto de instrucciones anteriores para generar impulso, pero agregue la opción -sICU_PATH="C:\icu4c-4_8"cuando ejecute b2 en el paso 5.

Si bien las instrucciones en el sitio web de Boost son útiles, aquí hay una versión condensada que también construye bibliotecas x64.

• Solo necesita hacer esto si está utilizando una de las bibliotecas mencionadas en la sección 3 de la página de instrucciones. (Por ejemplo, para usar Boost.Filesystem requiere compilación). Si no está usando ninguno de esos, simplemente descomprima y listo.

Construye las bibliotecas de 32 bits

Esto instala los archivos de encabezado Boost debajo C:\Boost\include\boost-(version)y las bibliotecas de 32 bits debajo C:\Boost\lib\i386. Tenga en cuenta que la ubicación predeterminada para las bibliotecas es C:\Boost\libpero querrá colocarlas en un i386directorio si planea construir para múltiples arquitecturas.

1. Descomprima Boost en un nuevo directorio.
2. Inicie un símbolo del sistema MSVC de 32 bits y cambie al directorio donde se descomprimió Boost.
3. Correr: bootstrap

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

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

5. Agregue C:\Boost\include\boost-(version)a su ruta de inclusión.

6. Agregue C:\Boost\lib\i386a su ruta de libs.

Construye las bibliotecas de 64 bits

Esto instala los archivos de encabezado Boost debajo C:\Boost\include\boost-(version)y las bibliotecas de 64 bits debajo C:\Boost\lib\x64. Tenga en cuenta que la ubicación predeterminada para las bibliotecas es C:\Boost\libpero querrá ubicarlas bajo un x64directorio si planea construir para múltiples arquitecturas.

1. Descomprima Boost en un nuevo directorio.
2. Inicie un símbolo del sistema MSVC de 64 bits y cambie al directorio donde se descomprimió Boost.
3. Correr: bootstrap
4. Correr: b2 toolset=msvc-12.0 --build-type=complete --libdir=C:\Boost\lib\x64 architecture=x86 address-model=64 install
   • Para Visual Studio 2012, use toolset=msvc-11.0
   • Para Visual Studio 2010, use toolset=msvc-10.0
5. Agregue C:\Boost\include\boost-(version)a su ruta de inclusión.
6. Agregue C:\Boost\lib\x64a su ruta de libs.

También puede probar -j% NUMBER_OF_PROCESSORS% como argumento, usará todos sus núcleos. Hace las cosas súper rápidas en mi quad core.

Podría recomendar el siguiente truco: crear un boost.propsarchivo especial

1. Abrir el administrador de la propiedad
2. Haga clic derecho en el nodo del proyecto y seleccione 'Agregar nueva hoja de propiedades del proyecto'.
3. Seleccione una ubicación y nombre su hoja de propiedades (por ejemplo, c: \ mystuff \ boost.props)
4. Modifique las carpetas adicionales Incluir y Lib a la ruta de búsqueda.

Este procedimiento tiene el valor de que el impulso se incluye solo en proyectos donde desea incluirlo explícitamente. Cuando tenga un nuevo proyecto que use boost, haga lo siguiente:

1. Abra el administrador de la propiedad.
2. Haga clic derecho en el nodo del proyecto y seleccione 'Agregar hoja de propiedades existente'.
3. Seleccione la hoja de propiedades de impulso.

EDITAR (siguiente edición de @ jim-fred):

El boost.propsarchivo resultante se parece a esto ...

<?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 de usuario para la ubicación del directorio de impulso (en este caso, D: \ boost_1_53_0) y otros dos parámetros: IncludePath y LibraryPath. Una instrucción #include <boost/thread.hpp>encontraría thread.hpp en el directorio apropiado (en este caso, D: \ boost_1_53_0 \ boost \ thread.hpp). El directorio 'stage \ lib \' puede cambiar según el directorio instalado.

Este archivo boost.props podría ubicarse en el D:\boost_1_53_0\directorio.

¿Qué partes de Boost necesitas? Muchas cosas son parte de TR1 que se envía con Visual Studio, por lo que simplemente podría decir, por ejemplo:

#include <tr1/memory>

using std::tr1::shared_ptr;

Según James, esto también debería funcionar (en C ++ 0x):

#include <memory>

using std::shared_ptr;

Este hilo ha existido por un tiempo, y pensé que agregaría algo sobre CÓMO construir Boost lo más rápido posible en su hardware específico.

Si tiene 4 o 6 núcleos, use -j5 o -j7 respectivamente. Ciertamente, no es la compilación estándar ni -j2 a menos que tenga un núcleo dual.

Estoy ejecutando un Sandy Bridge Extreme con stock de 3930K (6 núcleos) en mi estación principal, pero tengo 2600k (4 núcleos) en una caja de respaldo más antigua, y la tendencia es que obtengo los mejores tiempos de compilación de Boost con N + 1 procesos de construcción donde N es el número de núcleos físicos. N + 2 alcanza un punto de rendimientos decrecientes y los tiempos suben.

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

-j7 en 6 núcleos (2 minutos y 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 en 6 núcleos (3 minutos y 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 en 6 núcleos (3 minutos y 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 la compilación de 64 bits tarda un poco más, necesito hacer la misma comparación para esos y actualizar.

También una pequeña nota: si desea reducir el tiempo de compilación, puede agregar el indicador

-j2

para ejecutar dos compilaciones paralelas al mismo tiempo. Esto podría reducirlo a ver una película;)

Descargue impulso desde: http://www.boost.org/users/download/ por ejemplo, por svn

• Windows -> tortuga (la forma más simple)

Después de eso: cmd -> vaya al directorio boost ("D: \ boostTrunk" - donde realiza el pago o descarga y extrae el paquete): comando: bootstrap

creamos bjam.exe en ("D: \ boostTrunk") Después de eso: comando: bjam toolset = msvc-10.0 variant = debug, release threading = multi link = static (Tomará un tiempo ~ 20min.)

Después de eso: Abra Visual Studio 2010 -> cree un proyecto vacío -> vaya a las propiedades del proyecto -> set:

Pegue este código y verifique si 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

Así es como pude usar Boost:

1. Descargue y extraiga la versión zip de las bibliotecas Boost.
2. Ejecute el archivo bootstrap.bat y luego ejecute bjam.exe.
3. Espere aproximadamente 30 minutos más o menos.
4. Crea un nuevo proyecto en Visual Studio.
5. Vaya a proyecto -> propiedades -> Linker -> General -> Directorios de bibliotecas adicionales y agregue boost / stage / lib .
6. Vaya a proyecto -> propiedades -> C / C ++ -> General -> Incluir directorios adicionales y agregue un directorio de impulso .

¡Podrás construir tu proyecto sin ningún error!

Los instaladores de Windows ubicados aquí funcionaron perfectamente para mí. Tomé los siguientes pasos:

1. Siga el asistente de instalación hasta que termine.
2. Ejecute el estudio visual.
3. Crea un nuevo proyecto C ++
4. Abra las propiedades del proyecto (se puede encontrar haciendo clic derecho en el nombre del proyecto en el explorador de soluciones)
5. En "C / C ++> General> Incluir directorios adicionales", agregue la ruta donde impulsar el directorio raíz. El valor predeterminado para mi versión era C: \ local \ boost_1_63_0. El número después de "boost" es la versión de boost.
6. En las propiedades del proyecto, en "Vinculador> Directorios de biblioteca adicionales", agregue el directorio para los archivos de la biblioteca. El valor predeterminado para mi versión era C: \ local \ boost_1_63_0 \ lib64-msvc-14.0. El número después de "lib" está relacionado con el destino de compilación (32 bits o 64 bits en Visual Studio) y el número después de "msvc" está relacionado con la versión de Visual Studio (14.0 está relacionado con Visual Studio 2015, pero estoy usándolo con el Visual Studio 2017).

¡Buena suerte!

Una pequeña adición a la respuesta principal muy informativa de KTC:

Si está utilizando el Visual Studio c ++ 2010 Express gratuito, y logró que compilara binarios de 64 bits, y ahora quiere usarlo para usar una versión de 64 bits de las bibliotecas Boost, puede terminar con 32- bibliotecas de bits (su kilometraje puede variar, por supuesto, pero en mi máquina este es el caso triste).

Podría solucionar esto usando lo siguiente: entre los pasos descritos anteriormente como

1. Inicie un símbolo del sistema MSVC de 32 bits y cambie al directorio donde se descomprimió Boost.
2. Ejecutar: bootstrap

Inserté una llamada a 'setenv' para configurar el entorno. Para una compilación de lanzamiento, los pasos anteriores se convierten en:

1. Inicie un símbolo del sistema MSVC de 32 bits y cambie al directorio donde se descomprimió Boost.
2. Ejecute: "C: \ Archivos de programa \ Microsoft SDKs \ Windows \ v7.1 \ Bin \ setenv.cmd" / Release / x64
3. Ejecutar: bootstrap

Encontré esta información aquí: http://boost.2283326.n4.nabble.com/64-bit-with-VS-Express-again-td3044258.html

Un ejemplo minimalista para comenzar en Visual Studio:

1. Descargue y descomprima Boost desde aquí.

2.Cree un proyecto vacío de Visual Studio, utilizando un ejemplo de biblioteca de impulso que no requiere compilación 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.En las propiedades del proyecto de Visual Studio, configure los directorios de inclusión adicionales:

Para un ejemplo muy simple:

Cómo instalar las bibliotecas Boost en Visual Studio

Si no desea utilizar toda la biblioteca de impulso, solo un subconjunto:

Usando un subconjunto de las bibliotecas de impulso en Windows

Si específicamente desea saber ahora sobre las bibliotecas que requieren compilación:

Cómo usar las bibliotecas compiladas de Boost en Windows

Además, hay algo que encuentro muy útil. Utilice variables de entorno para sus rutas de impulso. (Cómo establecer variables de entorno en Windows, enlace en la parte inferior para 7,8,10) La variable BOOST_ROOT parece ser un lugar común y está configurada en la ruta raíz donde descomprime el impulso.

Luego, en Propiedades, c ++, general, Uso adicional de directorios de inclusión $(BOOST_ROOT). Luego, si / cuando pasa a una versión más nueva de la biblioteca de impulso, puede actualizar su variable de entorno para que apunte a esta versión más nueva. Como más de sus proyectos, use boost, no tendrá que actualizar los 'Directorios de inclusión adicionales' para todos ellos.

También puede crear una variable BOOST_LIB y señalarla donde se organizan las bibliotecas. Del mismo modo, para el enlazador-> directorios de bibliotecas adicionales, no tendrá que actualizar proyectos. Tengo algunas cosas viejas compiladas con vs10 y cosas nuevas con vs14, así que construí ambos sabores de boost lib en la misma carpeta. Entonces, si muevo un proyecto de vs10 a vs14, no tengo que cambiar las rutas de impulso.

NOTA: Si cambia una variable de entorno, no funcionará repentinamente en un proyecto VS abierto. VS carga variables al inicio. Por lo tanto, tendrá que cerrar VS y volver a abrirlo.