LG

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

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.

-mt, -gd, … voir https://www.boost.org/doc/libs/1_69_0/more/getting_started/windows.html

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.

Executor sur GitHub

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

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.

<note important>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.</note>

• boost::ref et std::ref.

Utiliser list_initializer.

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

short array_short[] = { 1, 2, 3 };
BOOST_FOREACH( short & i, array_short )
  ++i;

short array_short[] = { 1, 2, 3 };
for (short & i : array_short)
  ++i;

Et avec des containers multi valeurs :

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

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
}

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.

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

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);

Non testé la migration.

Non testé la migration.

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

Dans les cas basiques que j'ai eu, je n'ai pas eu de différences. Mais il y a quelques différences apparemment. Archive du 06/05/2019 le 03/03/2020

• boost::filesystem::ifstream :

#include <boost/filesystem/fstream.hpp>
 
boost::filesystem::path currentPath;
boost::filesystem::ifstream ifs(nextPath);

devient

#include <filesystem>
#include <fstream>
 
std::filesystem::path currentPath;
std::ifstream ifs(nextPath.c_str());

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

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.

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