Jak korzystać ze wzmocnienia w Visual Studio 2010

Jakie jest dobre wyjaśnienie krok po kroku, jak korzystać z biblioteki Boost w pustym projekcie w Visual Studio?

Chociaż odpowiedź Nate'a jest już całkiem dobra, zamierzam rozwinąć ją bardziej szczegółowo dla Visual Studio 2010 zgodnie z żądaniem i zawierać informacje na temat kompilacji w różnych opcjonalnych komponentach, które wymagają bibliotek zewnętrznych.

Jeśli używasz tylko bibliotek nagłówków, wszystko, co musisz zrobić, to cofnąć archiwizację pobierania pobudzającego i skonfigurować zmienne środowiskowe. Poniższa instrukcja ustawia zmienne środowiskowe tylko dla Visual Studio, a nie w całym systemie. Pamiętaj, że musisz to zrobić tylko raz.

1. Zarchiwizuj najnowszą wersję boost (1.47.0 w momencie pisania) do wybranego katalogu (np C:\boost_1_47_0.).
2. Utwórz nowy pusty projekt w Visual Studio.
3. Otwórz Menedżera właściwości i rozwiń jedną konfigurację dla wybranej platformy.
4. Wybierz i kliknij prawym przyciskiem myszy Microsoft.Cpp.<Platform>.user, a następnie wybierz, Propertiesaby otworzyć stronę właściwości do edycji.
5. Wybierz VC++ Directoriespo lewej.
6. Edytuj Include Directoriessekcję, aby uwzględnić ścieżkę do plików źródłowych doładowania.
7. W razie potrzeby powtórz kroki 3–6 dla innej wybranej platformy.

Jeśli chcesz użyć części wzmocnienia wymagającej budowania, ale żadnej z funkcji wymagających zewnętrznych zależności, to budowanie jej jest dość proste.

1. Zarchiwizuj najnowszą wersję boost (1.47.0 w momencie pisania) do wybranego katalogu (np C:\boost_1_47_0.).
2. Uruchom wiersz polecenia programu Visual Studio dla wybranej platformy i przejdź do miejsca, w którym znajduje się boost.
3. Uruchom: bootstrap.bataby zbudować b2.exe (wcześniej o nazwie bjam).

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

Idź na spacer / obejrzyj film lub 2 / ....

8. Wykonaj kroki 2–6 z powyższej instrukcji, aby ustawić zmienne środowiskowe.
9. Edytuj Library Directoriessekcję, aby uwzględnić ścieżkę do danych wyjściowych bibliotek doładowań. (Domyślną wartością dla powyższego przykładu i instrukcji będzie C:\boost_1_47_0\stage\lib. Zmień nazwę i przenieś katalog, jeśli chcesz mieć obok siebie x86 i x64 (np. <BOOST_PATH>\lib\x86& <BOOST_PATH>\lib\x64).
10. W razie potrzeby powtórz kroki 2–6 dla innej wybranej platformy.

Jeśli chcesz opcjonalnych komponentów, masz więcej pracy do zrobienia. To są:

• Filtry Boost.IOStreams Bzip2
• Boost.IOStreams filtry Zlib
• Boost.MPI
• Boost.Python
• Wsparcie ICU Boost.Regex

Filtry Boost.IOStreams Bzip2:

1. Zarchiwizuj najnowszą wersję biblioteki bzip2 (od chwili pisania wersji 1.0.6) do wybranego katalogu (np C:\bzip2-1.0.6.).
2. Postępuj zgodnie z drugim zestawem instrukcji powyżej, aby zbudować boost, ale dodaj opcję, -sBZIP2_SOURCE="C:\bzip2-1.0.6"gdy uruchomisz b2 w kroku 5.

Boost.IOStreams filtry Zlib

1. Zarchiwizuj najnowszą wersję biblioteki zlib (1.2.5 w chwili pisania) plików źródłowych do wybranego katalogu (np C:\zlib-1.2.5.).
2. Postępuj zgodnie z drugim zestawem instrukcji powyżej, aby zbudować boost, ale dodaj opcję, -sZLIB_SOURCE="C:\zlib-1.2.5"gdy uruchomisz b2 w kroku 5.

Boost.MPI

1. Zainstaluj dystrybucję MPI, taką jak Microsoft Compute Cluster Pack.
2. Wykonaj kroki 1–3 z drugiego zestawu instrukcji powyżej, aby zbudować boost.
3. Edytuj plik project-config.jamw katalogu <BOOST_PATH>wynikającym z uruchomienia bootstrap. Dodaj wiersz, który czyta using mpi ;(zwróć uwagę na spację przed „;”).
4. Wykonaj pozostałe kroki z drugiego zestawu instrukcji powyżej, aby zbudować ulepszenie. Jeśli automatyczne wykrywanie instalacji MPI nie powiedzie się, musisz poszukać i zmodyfikować odpowiedni plik kompilacji, aby wyszukać MPI we właściwym miejscu.

Boost.Python

1. Zainstaluj dystrybucję Python, taką jak ActivePython ActiveState. Upewnij się, że instalacja Pythona jest w ŚCIEŻCE.

2. Do pełnego zbudowania 32-bitowej wersji biblioteki wymagany jest 32-bitowy Python i podobnie w przypadku wersji 64-bitowej. Jeśli z tego powodu masz zainstalowanych wiele wersji, musisz powiedzieć b2, gdzie znaleźć konkretną wersję i kiedy jej użyć. Jednym ze sposobów jest dokonanie edycji pliku project-config.jamw katalogu <BOOST_PATH>wynikającym z uruchomienia programu ładującego. Dodaj następujące dwa wiersze, dostosowując odpowiednio do ścieżek instalacji i wersji Pythona (zwróć uwagę na spację przed „;”).

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

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

   Zauważ, że taka wyraźna specyfikacja Pythona obecnie powoduje niepowodzenie kompilacji MPI. Musisz więc wykonać osobne budowanie ze specyfikacją i bez niej, aby zbudować wszystko, jeśli budujesz także MPI.

3. Postępuj zgodnie z drugim zestawem instrukcji powyżej, aby zbudować ulepszenie.

Wsparcie ICU Boost.Regex

1. Zarchiwizuj najnowszą wersję biblioteki ICU4C (4.8 w momencie pisania) do wybranego katalogu (np C:\icu4c-4_8.).
2. Otwórz Visual Studio Solution w <ICU_PATH>\source\allinone.
3. Zbuduj wszystko dla konfiguracji debugowania i wydania dla wybranej platformy. Może wystąpić problem z budowaniem ostatnich wydań ICU4C w Visual Studio 2010, gdy dane wyjściowe dla kompilacji debugowania i wydania znajdują się w tym samym katalogu (co jest zachowaniem domyślnym). Możliwym obejściem jest wykonanie Kompilacji Wszystkie (powiedzmy, kompilacji debugowania), a następnie Przebudowanie wszystkich w 2. konfiguracji (np. Kompilacji wydania).
4. Jeśli budujesz dla x64, musisz uruchomić system operacyjny x64, ponieważ istnieją kroki po kompilacji, które wymagają uruchomienia 64-bitowej aplikacji, którą buduje.
5. Opcjonalnie usuń katalog źródłowy, gdy skończysz.
6. Postępuj zgodnie z drugim zestawem instrukcji powyżej, aby zbudować boost, ale dodaj opcję, -sICU_PATH="C:\icu4c-4_8"gdy uruchomisz b2 w kroku 5.

Chociaż instrukcje na stronie internetowej Boost są pomocne, tutaj jest wersja skrócona, która również buduje biblioteki x64.

• Musisz to zrobić tylko wtedy, gdy korzystasz z jednej z bibliotek wymienionych w sekcji 3 strony instrukcji. (Np. Użycie Boost.Filesystem wymaga kompilacji.) Jeśli nie używasz żadnego z nich, po prostu rozpakuj i idź.

Zbuduj biblioteki 32-bitowe

Spowoduje to zainstalowanie plików nagłówka Boost pod C:\Boost\include\boost-(version)i bibliotek 32-bitowych pod C:\Boost\lib\i386. Zauważ, że domyślną lokalizacją bibliotek jest, C:\Boost\libale będziesz chciał umieścić je w i386katalogu, jeśli planujesz budować dla wielu architektur.

1. Rozpakuj Boost w nowym katalogu.
2. Uruchom 32-bitowy wiersz polecenia MSVC i przejdź do katalogu, w którym rozpakowano Boost.
3. Biegać: bootstrap

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

   • W przypadku programu Visual Studio 2012 użyj toolset=msvc-11.0
   • W przypadku programu Visual Studio 2010 użyj toolset=msvc-10.0
   • W przypadku programu Visual Studio 2017 użyj toolset=msvc-14.1

5. Dodaj C:\Boost\include\boost-(version)do swojej ścieżki dołączania.

6. Dodaj C:\Boost\lib\i386do swojej ścieżki libs.

Zbuduj biblioteki 64-bitowe

Spowoduje to zainstalowanie plików nagłówka Boost pod C:\Boost\include\boost-(version)i bibliotek 64-bitowych pod C:\Boost\lib\x64. Zauważ, że domyślną lokalizacją bibliotek jest, C:\Boost\libale będziesz chciał umieścić je w x64katalogu, jeśli planujesz budować dla wielu architektur.

1. Rozpakuj Boost w nowym katalogu.
2. Uruchom 64-bitowy wiersz polecenia MSVC i przejdź do katalogu, w którym rozpakowano Boost.
3. Biegać: bootstrap
4. Biegać: b2 toolset=msvc-12.0 --build-type=complete --libdir=C:\Boost\lib\x64 architecture=x86 address-model=64 install
   • W przypadku programu Visual Studio 2012 użyj toolset=msvc-11.0
   • W przypadku programu Visual Studio 2010 użyj toolset=msvc-10.0
5. Dodaj C:\Boost\include\boost-(version)do swojej ścieżki dołączania.
6. Dodaj C:\Boost\lib\x64do swojej ścieżki libs.

Możesz także wypróbować -j% NUMBER_OF_PROCESSORS% jako argument, że użyje wszystkich twoich rdzeni. Sprawia, że ​​wszystko jest super szybkie w moim quadzie.

Mógłbym polecić następującą sztuczkę: Utwórz specjalny boost.propsplik

1. Otwórz zarządcę nieruchomości
2. Kliknij prawym przyciskiem myszy węzeł projektu i wybierz „Dodaj nowy arkusz właściwości projektu”.
3. Wybierz lokalizację i nazwij arkusz właściwości (np. C: \ mystuff \ boost.props)
4. Zmodyfikuj dodatkowe foldery Include i Lib w ścieżce wyszukiwania.

Ta procedura ma tę wartość, że zwiększenie jest uwzględniane tylko w projektach, w których chcesz je wyraźnie uwzględnić. Gdy masz nowy projekt, który korzysta ze wzmocnienia, wykonaj:

1. Otwórz zarządcę nieruchomości.
2. Kliknij prawym przyciskiem myszy węzeł projektu i wybierz „Dodaj istniejący arkusz właściwości”.
3. Wybierz arkusz właściwości doładowania.

EDYCJA (po edycji z @ jim-fred):

Plik wynikowy boost.propswygląda mniej więcej tak:

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

Zawiera makro użytkownika dla lokalizacji katalogu boost (w tym przypadku D: \ boost_1_53_0) oraz dwa inne parametry: IncludePath i LibraryPath. Instrukcja #include <boost/thread.hpp>znalazłaby thread.hpp w odpowiednim katalogu (w tym przypadku D: \ boost_1_53_0 \ boost \ thread.hpp). Katalog „stage \ lib \” może ulec zmianie w zależności od katalogu zainstalowanego.

Ten plik boost.props może znajdować się w D:\boost_1_53_0\katalogu.

Jakich części wzmocnienia potrzebujesz? Wiele rzeczy jest częścią TR1, który jest dostarczany z Visual Studio, więc możesz po prostu powiedzieć, na przykład:

#include <tr1/memory>

using std::tr1::shared_ptr;

Według Jamesa powinno to również działać (w C ++ 0x):

#include <memory>

using std::shared_ptr;

Ten wątek istnieje już od jakiegoś czasu i pomyślałem, że dodam coś o tym, jak zbudować Boost tak szybko, jak to możliwe na twoim konkretnym sprzęcie.

Jeśli masz 4 lub 6 rdzeni, użyj odpowiednio -j5 lub -j7. Z pewnością nie jest to standardowa wersja ani -j2, chyba że rzeczywiście masz dwurdzeniowy.

Używam Sandy Bridge Extreme z zegarem 3930K (6-rdzeniowym) na mojej głównej stacji, ale mam 2600k (4-rdzeniowy) na starszej skrzynce zapasowej, a trend jest taki, że otrzymuję najlepsze czasy kompilacji Boost z N + 1 procesy kompilacji, w których N jest liczbą rdzeni fizycznych. N + 2 osiąga punkt malejących zwrotów i czasy rosną.

Uwagi: Hyperthreading jest włączony, 32 GB pamięci RAM DDR3, Samsung 840 EVO SSD.

-j7 na 6 rdzeniach (2 minuty i 51 sekund) (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 na 6 rdzeniach (3 minuty i 2 sekundy) (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 na 6 rdzeniach (3 minuty i 17 sekund) (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)

Zwracam uwagę, że 64-bitowa kompilacja trwa nieco dłużej, muszę zrobić to samo porównanie dla nich i zaktualizować.

Również mała uwaga: jeśli chcesz skrócić czas kompilacji, możesz dodać flagę

-j2

aby uruchomić dwie równoległe kompilacje jednocześnie. To może zredukować go do oglądania jednego filmu;)

Pobierz przyspieszenie z: http://www.boost.org/users/download/ np. Przez svn

• Windows -> żółw (najprostszy sposób)

Następnie: cmd -> przejdź do katalogu boost („D: \ boostTrunk” - gdzie kasujesz lub pobierasz i rozpakowujesz pakiet): polecenie: bootstrap

stworzyliśmy bjam.exe w („D: \ boostTrunk”) Następnie: polecenie: zestaw narzędzi bjam = wariant msvc-10.0 = debugowanie, zwolnienie wątków = multi link = statyczny (zajmie to trochę czasu ~ 20 min.)

Następnie: Open Visual studio 2010 -> utwórz pusty projekt -> przejdź do właściwości projektu -> ustaw:

Wklej ten kod i sprawdź, czy działa?

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

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

Oto, w jaki sposób mogłem użyć wzmocnienia:

1. Pobierz i rozpakuj wersję zip bibliotek Boost.
2. Uruchom plik bootstrap.bat, a następnie uruchom plik bjam.exe.
3. Poczekaj około 30 minut.
4. Utwórz nowy projekt w Visual Studio.
5. Przejdź do projektu -> właściwości -> Linker -> Ogólne -> Dodatkowe katalogi biblioteczne i dodaj do niego katalog boost / stage / lib .
6. Przejdź do projektu -> właściwości -> C / C ++ -> Ogólne -> Dodatkowe katalogi Uwzględnij i dodaj do niego katalog boost .

Będziesz mógł zbudować swój projekt bez żadnych błędów!

Instalatory Windows znajdujące się tutaj działały idealnie dla mnie. Podjąłem następujące kroki:

1. Postępuj zgodnie z instrukcjami kreatora instalacji, aż zakończysz.
2. Uruchom studio wizualne.
3. Utwórz nowy projekt w C ++
4. Otwórz właściwości projektu (można je znaleźć, klikając prawym przyciskiem myszy nazwę projektu w eksploratorze rozwiązań)
5. W sekcji „C / C ++> Ogólne> Dodatkowe katalogi dołączające” dodaj ścieżkę do katalogu głównego doładowania. Domyślna wersja mojej wersji to C: \ local \ boost_1_63_0. Liczba po „boost” to wersja boost.
6. We właściwościach projektu w polu „Linker> Dodatkowe katalogi biblioteczne” dodaj katalog plików bibliotecznych. Domyślna wersja mojej wersji to C: \ local \ boost_1_63_0 \ lib64-msvc-14.0. Liczba po „lib” jest związana z celem kompilacji (32-bitowym lub 64-bitowym w Visual Studio), a liczba po „msvc” jest związana z wersją Visual Studio (14.0 jest związana z Visual Studio 2015, ale jestem używając go w Visual Studio 2017).

Powodzenia!

Mały dodatek do bardzo pouczającej głównej odpowiedzi KTC:

Jeśli korzystasz z bezpłatnego programu Visual Studio c ++ 2010 Express i udało Ci się go skompilować do 64-bitowych plików binarnych, a teraz chcesz go użyć do korzystania z 64-bitowej wersji bibliotek Boost, możesz otrzymać 32- biblioteki bitów (przebieg może się oczywiście różnić, ale na mojej maszynie jest to smutny przypadek).

Mógłbym to naprawić, wykonując następujące czynności: pomiędzy krokami opisanymi powyżej jako

1. Uruchom 32-bitowy wiersz polecenia MSVC i przejdź do katalogu, w którym rozpakowano Boost.
2. Uruchom: bootstrap

Wstawiłem wywołanie „setenv”, aby ustawić środowisko. W przypadku kompilacji wersji powyższe kroki to:

1. Uruchom 32-bitowy wiersz polecenia MSVC i przejdź do katalogu, w którym rozpakowano Boost.
2. Uruchom: „C: \ Program Files \ Microsoft SDKs \ Windows \ v7.1 \ Bin \ setenv.cmd” / Release / x64
3. Uruchom: bootstrap

Znalazłem te informacje tutaj: http://boost.2283326.n4.nabble.com/64-bit-with-VS-Express-again-td3044258.html

Minimalistyczny przykład na początek w Visual Studio:

1. Pobierz i rozpakuj Boost tutaj.

2. Utwórz pusty projekt Visual Studio, korzystając z przykładowej biblioteki boost, która nie wymaga osobnej kompilacji:

#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. We właściwościach projektu Visual Studio ustaw Dodatkowe katalogi Uwzględnij:

Dla bardzo prostego przykładu:

Jak zainstalować biblioteki Boost w Visual Studio

Jeśli nie chcesz korzystać z całej biblioteki doładowań, wystarczy podzbiór:

Korzystanie z podzbioru bibliotek doładowań w systemie Windows

Jeśli chcesz teraz o bibliotekach wymagających kompilacji:

Jak korzystać z bibliotek skompilowanych Boost w systemie Windows

Ponadto jest coś, co uważam za bardzo przydatne. Użyj zmiennych środowiskowych dla swoich ścieżek doładowania. (Jak ustawić zmienne środowiskowe w systemie Windows, link u dołu dla 7,8,10) Zmienna BOOST_ROOT wydaje się być już powszechnym miejscem i jest ustawiona na ścieżkę root, w której rozpakowujesz boost.

Następnie we Właściwościach, c ++, ogólne, użycie dodatkowych Uwzględnij katalogi $(BOOST_ROOT). Następnie, jeśli / kiedy przejdziesz do nowszej wersji biblioteki kryteriów, możesz zaktualizować zmienną środowiskową, aby wskazywała na tę nowszą wersję. Wraz ze wzrostem liczby projektów korzystaj ze wzmocnienia, nie będziesz musiał aktualizować „Dodatkowych katalogów dołączania” dla wszystkich z nich.

Możesz także utworzyć zmienną BOOST_LIB i wskazać ją w miejscu, w którym znajdują się biblioteki lib. Podobnie w przypadku Linkera-> Dodatkowe katalogi biblioteczne nie będziesz musiał aktualizować projektów. Mam kilka starych rzeczy zbudowanych z vs10 i nowych rzeczy z vs14, więc zbudowałem oba smaki boost lib do tego samego folderu. Więc jeśli przeniosę projekt z vs10 na vs14, nie muszę zmieniać ścieżek ulepszeń.

UWAGA: Jeśli zmienisz zmienną środowiskową, nie zadziała ona nagle w otwartym projekcie VS. VS ładuje zmienne przy starcie. Będziesz musiał zamknąć VS i ponownie go otworzyć.