Boost is a collection of C++ libraries. Each library has been reviewed by many professional programmers before being accepted by Boost. Libraries are tested on multiple platforms using many compilers and many C++ standard library implementations. While using Boost, you can be sure that you are using one of the most portable, fast, and reliable solutions that is distributed under a license suitable for commercial and open source projects.
1. Install CMake
cd ~
wget https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.5.tar.gz
tar xf cmake-3.14.5.tar.gz
cd cmake-3.14.5
./bootstrap --parallel=10
make -j4
sudo make -j4 install
2. Install Boost
cd ~
wget https://boostorg.jfrog.io/artifactory/main/release/1.69.0/source/boost_1_69_0.tar.gz
tar xf boost_1_69_0.tar.gz
cd boost_1_69_0
./bootstrap.sh
./b2 ... cxxflags="-std=c++0x -stdlib=libc++" linkflags="-stdlib=libc++" ...
sudo ./b2 toolset=gcc -j4 install
- 1. Program with option base with Boost.program_options
- 2. Program with option short with Boost.program_options
- 3. Storing any value in a container/variable with Boost.any
- 4. Storing multiple chosen types in a container/variable with Boost.variant
- 5. Using a safer way to work with a container that stores multiple chosen types with Boost.any
- 6. Using a safer way to work with a container that stores multiple chosen types with Boost.Variant
- 7. Returning a value or flag where there is no value with Boost.Optional
- 8. Returning an array from a function with Boost.array
- 9. Combining multiple values into one with Boost.Tuple
- 10. Binding and reordering function parameters with Boost.bind
- 11. Getting a human-readable type name with Boost.type_index
- 12. Using the C++11 move emulation with Boost.swap
- 13. Making a noncopyable class with Boost.noncopyable
- 14. Making a noncopyable but movable class
- 15. Using C++14 and C++11 algorithms with Boost.algorithm
- 1. Managing local pointers to classes that do not leave scope
- 2. Reference counting of pointers to classes used across functions
- 3. Managing pointers to arrays that do not leave scope
- 4. Reference counting of pointers to arrays used across functions
- 5. Storing any functional objects in a variable
- 6. Passing function pointer in a variable
- 7. Passing C++11 lambda functions in a variable
- 8. Containers of pointers with Boost.PointerContainer
- 9. Do it at scope exit with Boost.scope_exit
- 10. Initializing the base class by the member of the derived class with Boost.Utility
- 1. Converting strings to numbers with Boost.LexicalCast
- 2. Converting numbers to strings with Boost.LexicalCast
- 3. Converting numbers to numbers with Boost.LexicalCast
- 4. Converting user-defined types to/from strings
- 5. Converting smart pointers
- 6. Casting polymorphic objects with Boost::polymorphic_cast
- 7. Parsing simple input with Boost.Spirit
- 8. Parsing complex input with Boost.Spirit
- 1. Checking sizes at compile time with Boost.StaticAssert and Boost.TypeTraits
- 2. Enabling function template usage for integral types with Boost.Core and Boost.TypeTraits
- 3. Disabling function template usage for real types with Boost.Core and Boost.TypeTraits
- 4. Creating a type from a number
- 5. Implementing a type trait with Boost.TypeTrait
- 6. Selecting an optimal operator for a template parameter with Boost.TypeTrait
- 7. Getting a type of expression in C++03 with Boost.Typeof
- 1. Creating a thread of execution
- 2. Syncing access to a common resource use boost::mutex
- 3. Fast access to common resource using atomics
- 4. Creating work_queue class
- 5. Multiple-readers-single-writer lock
- 6. Creating variables that are unique per thread
- 7. Interrupting a thread
- 8. Manipulating a group of threads
- 9. Initializing a shared variable safely
- 10. Locking multiple mutexes
- 1. Registering a task for an arbitrary data type processing
- 2. Making timers and processing timer events as tasks
- 3. Network communication as a task and Accepting incoming connections
- 4. Executing different tasks in parallel
- 5. Pipeline tasks processing
- 6. Making a nonblocking barrier
- 7. Storing an exception and making a task from it
- 8. Getting and processing system signals as tasks
- 1. Changing cases and case-insensitive comparison
- 2. Matching strings using regular expressions
- 3. Formatting strings using safe printf-like functions
- 4. Replacing and erasing strings
- 5. Representing a string with two iterators
- 6. Using a reference to string type
- 1. Using type vector of types
- 2. Manipulating a vector of types
- 3. Getting a function's result type at compile time
- 4. Making a higher-order metafunction
- 5. Evaluating metafunctions lazily
- 6. Converting all the tuple elements to strings
- 7. Splitting tuples
- 8. Manipulating heterogeneous containers in C++14
- 1. Storing a few elements in a sequence container
- 2. Storing at most N elements in the sequence container
- 3. Comparing strings in an ultra-fast manner
- 4. Using an unordered set and map
- 5. Making a map, where value is also a key
- 6. Using multi-index containers
- 7. Getting benefits of a single linked list and memory pool
- 8. Using flat associative containers
- 1. Detecting an OS and compiler
- 2. Detecting int128 support
- 3. Detecting and bypassing disabled RTTI
- 4. Writing metafunctions using simpler methods
- 5. Reducing code size and increasing performance of user-defined types (UDTs) in C++11
- 6. The portable way to export and import functions and classes
- 7. Detecting the Boost version and getting latest features
- 1. Listing files in a directory
- 2. Erasing and creating files and directories
- 3. Writing and using plugins
- 4. Getting backtrace – current call sequence
- 5. Passing data quickly from one process to another
- 6. Syncing interprocess communications
- 7. Using pointers in a shared memory
- 8. The fastest way to read files
- 9. Coroutines - saving the state and postponing the execution