====Windows====
===Compilation===
<code bash>
git clone https://github.com/boostorg/boost.git
git checkout boost-1.69.0 --recurse-submodules
# C'est celui dans le dossier boost pas boost\tools\build
bootstrap.bat
b2 -j4 toolset=msvc-14.0 address-model=64 architecture=x86 threading=multi --build-type=complete variant=debug,release install --prefix=boost.install
</code>
Compilation pour Visual Studio 2015 et pour des programmes en 64 bits (''address-model''). ''architecture'' vaut ''x86'' que ce soit pour ''address-model'' à 32 ou 64.

Il n'y a pas ''link'' ni ''runtime-link'' de défini. Les deux versions ''static'' et ''shared'' seront compilés.

On génère simultanément la version de ''release'' et ''debug''.

===Nommage de la dll===
''-mt'', ''-gd'', ... voir [[https://www.boost.org/doc/libs/1_69_0/more/getting_started/windows.html]]

====boost::asio::execution_context====
L'exécuteur a les caractéristiques suivantes :
  * Fonctionnement entre thread, pas entre application via TCP,
  * Toujours en fonctionnement. En attente s'il n'a plus de travail à faire.

{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/boost/executor/executor.h}}

{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/boost/executor/executor.cpp}}

{{gh>https://github.com/bansan85/wiki_le_garrec_fr/blob/master/cpp/boost/executor/main.cpp}}
====boost::algorithm====
===boost::algorithm::join et boost::adaptors::transformed===
<code cpp>
#include <iostream>

#include <boost/algorithm/string/join.hpp>
#include <boost/range/adaptor/transformed.hpp>

#include <string>

struct Data
{
  std::string name;
  std::string version;
};

int main()
{
  std::vector<Data> v{ {"Name1", "Version 1"}, {"Name2", "Version 2"} };

  std::cout <<
  boost::algorithm::join(
    v |
    boost::adaptors::transformed(
      [](const Data& firmware)
      {
        return firmware.name + " / " + firmware.version;
      }
    ),
    ", ") <<
  std::endl;

  return 0;
}
</code>

====Migrer de boost vers std====
===Pointeur intelligent===

Aucune différence entre :
  * ''std::shared_ptr'' et ''boost::shared_ptr'',
  * ''std::unique_ptr'' et ''boost::unique_ptr'',
  * ''std::weak_ptr'' et ''boost::weak_ptr'',
  * ''std::make_shared'' et ''boost::make_shared'',
  * ''std::enable_shared_from_this'' et ''boost::enable_shared_from_this''.

<WRAP center round important 60%>
''shared_ptr'', ''make_shared'' et ''enable_shared_from_this'' doivent tous venir de la même libraire. L'un en version ''std'' et l'autre en version ''boost'' sont incompatibles.
</WRAP>

  * boost::ref et std::ref.

===assign===

Utiliser list_initializer.

<code cpp>
//const std::list<int> primes = boost::assign::list_of(2)(3)(5)(7)(11);
const std::list<int> primes {2, 3, 5, 7, 11};
</code>

===foreach===

<code cpp>
short array_short[] = { 1, 2, 3 };
BOOST_FOREACH( short & i, array_short )
  ++i;
</code>

<code cpp>
short array_short[] = { 1, 2, 3 };
for (short & i : array_short)
  ++i;
</code>

Et avec des containers multi valeurs :

<code cpp>
std::map<const int, int> m;
int key, value;
BOOST_FOREACH(boost::tie(key, value), m)
{
  // do something with key and value here
}
</code>

<code cpp>
std::map<int, int> m;
int key, value;
// Ici, key sera en lecture seule (implicite à la structure de std::map) et value sera accessible en écriture.
// En cas de présente / absence explicite de const, cela s'applique obligatoirement à toutes les variables.
for(auto & [key, value] : m)
{
  // do something with key and value here
}
</code>

===optional===

Il ne devrait pas y avoir de problèmes. Il faut noter que ''std'' ne supporte pas les références : ''std::optional<int&>''.

''boost::none'' devient ''std::nullopt''.

===regex===

Cette fonctionnalité était très peu utilisée.

<code cpp>
boost::regex_search(name, whatpath, expmatchIndexPath, boost::match_default);
// std::regex_search ne supporte pas le 4ème paramètre.
std::regex_search(name, whatpath, expmatchIndexPath);
</code>

Sinon, ''boost::cmatch'' et ''boost::regex'' sont identiques à ''std::cmatch'' et ''std::regex''.

===variant===

<code cpp>
boost::variant<int, double> v = 5;
double d = boost::get<double>(v); // Génère une exception
double *d = boost::get<double>(&v); // Renvoi nullptr
</code>

devient

<code cpp>
std::variant<int, double> v = 5;
double d = std::get<double>(v); // Génère une exception
double *d = std::get_if<double>(&v); // Renvoi nullptr
</code>

''boost::apply_visitor'' devient ''std::visit''.

Attention, ''boost::variant<int, int>'' est accepté mais pas ''std::variant<int, int>''. Dans tous les cas, il ne faut pas y avoir deux fois le même type.

===tuple===

Non testé la migration.

===bind===

Les deux sont compatibles. Mais il est préférable de les remplacer par des fonctions lambda.

===filesystem===

Dans les cas basiques que j'ai eu, je n'ai pas eu de différences. Mais il y a [[https://www.bfilipek.com/2019/05/boost-to-stdfs.html|quelques différences]] apparemment. {{ :lib:boost:bartek_s_coding_blog_converting_from_boost_to_std_filesystem_2020-03-03_10_10_25_am_.html |Archive du 06/05/2019 le 03/03/2020}}

  * ''boost::filesystem::ifstream''

<code cpp>
#include <boost/filesystem/fstream.hpp>

boost::filesystem::path currentPath;
boost::filesystem::ifstream ifs(nextPath);
</code>

devient

<code cpp>
#include <filesystem>
#include <fstream>

std::filesystem::path currentPath;
std::ifstream ifs(nextPath.c_str());
</code>

  * ''boost::filesystem::copy_option''

Il devient ''std::filesystem::copy_options''. Le nom des enum est différent :

''overwrite_if_exists'' devient ''overwrite_existing''.
''fail_if_exists'' devient ''skip_existing''.

  * Deprecated

''leaf()'' devient ''filename()''.

[[https://www.boost.org/doc/libs/1_72_0/libs/filesystem/doc/deprecated.html|Deprecated names and features]] {{ :lib:boost:filesystem_deprecated_features_2020-04-21_2_58_20_pm_.html |Archive du 29/12/2014 le 21/04/2020}}

===thread===

  * ''thread.join'' : si le thread n'est pas ''joinable()'', ''boost'' ne fait rien mais ''std'' génère une exception.

===shared_mutex===

Il n'y a pas d'équivalent car ''std'' ne supporte pas le timeout.

Il faut alors faire une boucle où on passe son temps à faire un ''try_lock_shared'' pendant le temps nécessaire.

===scoped_array===

Peut se remplacer sans problème par un ''std::vector''.

===algorithm===
  * string

<code cpp>
std::string str;
return boost::to_upper_copy(str);
</code>

devient

<code cpp>
std::string str;
std::transform(str.begin(), str.end(), str.begin(), ::toupper);
return std::move(str);
</code>

===boost::lexical_cast===

''boost::lexical_cast<std::string>(number)'' devient ''std::to_string(number)''.