std::is_const<T>::value

std::is_const_v<T> // since C++17

namespace std {
    template<typename T>
    constexpr bool is_const_v = is_const<T>::value;
}

if (std::is_signed_v<char>) {
    ...
}

if constexpr (std::is_signed_v<char>) {
    ...
}

// C<T>类的主要模板
template<typename T, bool = std::is_pointer_v<T>>
class C {
    ...
};
// 指针类型的部分特殊化。
template<typename T>
class C<T, true> {
    ...
};

int a[5][7];
std::cout << std::extent_v<decltype(a)> << '\n'; // prints 5
std::cout << std::extent_v<decltype(a),1> << '\n'; // prints 7

template<typename T>
struct D : std::string, std::complex<T> {
    std::string data;
};
D<float> s{{"hello"}, {4.5,6.7}, "world"}; // OK since C++17
std::cout << std::is_aggregate<decltype(s)>::value; // outputs: 1 (true)

namespace std {
    template<bool B>
    using bool_constant = integral_constant<bool, B>; // since C++17
    using true_type = bool_constant<true>;
    using false_type = bool_constant<false>;
}

// 主模板：通常 T 不是 void 类型
template<typename T>
struct IsVoid : std::false_type {
};
// void 类型的特化:
template<>
struct IsVoid<void> : std::true_type {
};

template<typename T>
struct IsLargerThanInt
    : std::bool_constant<(sizeof(T) > sizeof(int))> {
    }

template<typename T>
void foo(T x)
{
    if constexpr(IsLargerThanInt<T>::value) {
        ...
    }
}

template<typename T>
inline static constexpr auto IsLargerThanInt_v = IsLargerThanInt<T>::value;

template<typename T>
void foo(T x)
{
    if constexpr(IsLargerThanInt_v<T>) {
        ...
    }
}

template<typename T>
struct IsNothrowMoveConstructibleT
    : std::bool_constant<noexcept(T(std::declval<T>()))> {
    };

namespace std {
    template<typename...> using void_t = void;
}

#include <utility> // 对于declval<>来说
#include <type_traits> // 为true_type，false_type，和void_t
// 主模板:
template<typename, typename = std::void_t<>>
struct HasVarious : std::false_type {
};

// 部分专业（可能会被SFINAE所取代）:
template<typename T>
struct HasVarious<T, std::void_t<decltype(std::declval<T>().begin()),
typename T::difference_type,
typename T::iterator>>
    : std::true_type {
    };

#ifndef TIMER_HPP
#define TIMER_HPP
#include <iostream>
#include <string>
#include <chrono>
/********************************************
* timer to print elapsed time
********************************************/
class Timer
{
private:
    std::chrono::steady_clock::time_point last;
public:
    Timer()
        : la st{std::chrono::steady_clock::now()} {
        }
    void printDiff(const std::string& msg = "Timer diff: ") {
        auto now{std::chrono::steady_clock::now()};
        std::chrono::duration<double, std::milli> diff{now - last};
        std::cout << msg << diff.count() << "ms\n";
        last = std::chrono::steady_clock::now();
    }
};
#endif // TIMER_HPP

#include <vector>
#include <iostream>
#include <algorithm>
#include <numeric>
#include <execution> // 对于执行策略
#include "timer.hpp"
int main()
{
    int numElems = 1000;
    struct Data {
        double value; // 初始值
        double sqrt; // 并行计算平方根
    };
    // 初始化没有平方根的 NumElems 值:
    std::vector<Data> coll;
    coll.reserve(numElems);
    for (int i=0; i<numElems; ++i) {
        coll.push_back(Data{i * 4.37, 0});
    }
    // 平方根的并行计算:
    for_each(std::execution::par,
             coll.begin(), coll.end(),
             [](auto& val) {
                 val.sqrt = std::sqrt(val.value);
             });
}

#include <algorithm>
#include <execution>
...
for_each(std::execution::par,
         coll.begin(), coll.end(),
         [](auto& val) {
             val.sqrt = std::sqrt(val.value);
         });

#include <vector>
#include <iostream>
#include <algorithm>
#include <numeric>
#include <execution> // for the execution policy
#include "timer.hpp"
int main()
{
    int numElems = 1000;
    struct Data {
        double value; // 初始值
        double sqrt; // 并行计算平方根
    };
    // 初始化没有平方根的 NumElems 值:
    std::vector<Data> coll;
    coll.reserve(numElems);
    for (int i=0; i<numElems; ++i) {
        coll.push_back(Data{i * 4.37, 0});
    }
    // 平方根的并行计算:
    for_each(std::execution::par,
             coll.begin(), coll.end(),
             [](auto& val) {
                 val.sqrt = std::sqrt(val.value);
             });
}

auto num = std::count_if(std::execution::par, // execute policy
                         coll.cbegin(), coll.cend(), // 范围
                         [](int elem){ //准则
                             return elem % 2 == 0;
                         });

std::vector<std::string> coll;
for (int i=0; i < numElems / 2; ++i) {
    coll.emplace_back("id" + std::to_string(i));
    coll.emplace_back("ID" + std::to_string(i));
}

id0 ID0 id1 ID1 id2 ID2 id3 ... id99 ID99 id100 ID100 ...

sort(coll.begin(), coll.end());

sort(std::execution::seq, coll.begin(), coll.end());

sort(std::execution::par, coll.begin(), coll.end());

sort(std::execution::par_seq, coll.begin(), coll.end());

sort(std::execution::par,
     coll.begin(), coll.end(),
     [] (const auto& a, const auto& b) {
         return a.substr(2) < b.substr(2);
     });

sort(coll.begin(), coll.end(),
     [] (const auto& a, const auto& b) {
         return std::string_view{a}.substr(2) < std::string_view{b}.substr(2);
     });

sort(std::execution::par,
     coll.begin(), coll.end(),
     [] (const auto& a, const auto& b) {
         return std::string_view{a}.substr(2) < std::string_view{b}.substr(2);
     });

sort(coll.begin(), coll.end(),
     [] (const auto& a, const auto& b) {
         return a.substr(2) < b.substr(2);

#include <iostream>
#include <vector>
#include <numeric> // for accumulate()
void printSum(long num)
{
    // 用 1 2 3 4 的 num 个序列创建 coll:
    std::vector<long> coll;
    coll.reserve(num * 4);
    for (long i=0; i < num; ++i) {
        coll.insert(coll.end(), {1, 2, 3, 4});
    }
    auto sum = std::accumulate(coll.begin(), coll.end(),
                               0L);
    std::cout << "accumulate(): " << sum << '\n';
}
int main()
{
    printSum(1);
    printSum(1000);
    printSum(1000000);
    printSum(10000000);
}

accumulate(): 10
accumulate(): 10000
accumulate(): 10000000

#include <iostream>
#include <vector>
#include <numeric> // for reduce()
#include <execution>
void printSum(long num)
{
    // 用 1 2 3 4 的 num 个序列创建 coll:
    std::vector<long> coll;
    coll.reserve(num * 4);
    for (long i=0; i < num; ++i) {
        coll.insert(coll.end(), {1, 2, 3, 4});
    }
    auto sum = std::reduce(std::execution::par,
                           coll.begin(), coll.end(),
                           0L);
    std::cout << "reduce(): " << sum << '\n';
}
int main()
{
    printSum(1);
    printSum(1000);
    printSum(1000000);
    printSum(10000000);
}

#include <iostream>
#include <vector>
#include <numeric>
#include <execution>
void printSum(long num)
{
    // 用 0.1 0.3 0.0001 的 num 个序列创建 coll:
    std::vector<double> coll;
    coll.reserve(num * 4);
    for (long i=0; i < num; ++i) {
        coll.insert(coll.end(), {0.1, 0.3, 0.00001});
    }
    auto sum1 = std::accumulate(coll.begin(), coll.end(),
                                0.0);
    std::cout << "accumulate(): " << sum1 << '\n';
    auto sum2 = std::reduce(std::execution::par,
                            coll.begin(), coll.end(),
                            0.0);
    std::cout << "reduce(): " << sum2 << '\n';
    std::cout << (sum1==sum2 ? "equal\n" : "differ\n");
}
#include<iomanip>
int main()
{
    std::cout << std::setprecision(20);
    printSum(1);
    printSum(1000);
    printSum(1000000);
    printSum(10000000);
}

accumulate(): 0.40001
reduce(): 0.40001
equal
accumulate(): 400.01
reduce(): 400.01
differ
accumulate(): 400010
reduce(): 400010
differ
accumulate(): 4.0001e+06
reduce(): 4.0001e+06
differ

std::cout << std::setprecision(20);

accumulate(): 0.40001000000000003221
reduce(): 0.40001000000000003221
equal
accumulate(): 400.01000000000533419
reduce(): 400.01000000000010459
differ
accumulate(): 400009.99999085225863
reduce(): 400009.9999999878346
differ
accumulate(): 4000100.0004483023658
reduce(): 4000100.0000019222498
differ

#include <iostream>
#include <vector>
#include <numeric> // 对于 accumulate()
void printSum(long num)
{
    // 用 1 2 3 4 的 num 个序列创建 coll：
    std::vector<long> coll;
    coll.reserve(num * 4);
    for (long i=0; i < num; ++i) {
        coll.insert(coll.end(), {1, 2, 3, 4});
    }
    auto squaredSum = [] (auto sum, auto val) {
        return sum + val * val;
    };
    auto sum = std::accumulate(coll.begin(), coll.end(),
                               0L,
                               squaredSum);
    std::cout << "accumulate(): " << sum << '\n';
}
int main()
{
    printSum(1);
    printSum(1000);
    printSum(1000000);
    printSum(10000000);
}

auto squaredSum = [] (auto sum, auto val) {
    return sum + val * val;
};

accumulate(): 30
accumulate(): 30000
accumulate(): 30000000
accumulate(): 300000000

#include <iostream>
#include <vector>
#include <numeric> // 对于reduce()
#include <execution>
void printSum(long num)
{
    // 用 1 2 3 4 的 num 个序列创建 coll：
    std::vector<long> coll;
    coll.reserve(num * 4);
    for (long i=0; i < num; ++i) {
        coll.insert(coll.end(), {1, 2, 3, 4});
    }
    auto squaredSum = [] (auto sum, auto val) {
        return sum + val * val;
    };
    auto sum = std::reduce(std::execution::par,
                           coll.begin(), coll.end(),
                           0L,
                           squaredSum);
    std::cout << "reduce(): " << sum << '\n';
}
int main()
{
    printSum(1);
    printSum(1000);
    printSum(1000000);
    printSum(10000000);
}

reduce(): 30
reduce(): 30000
reduce(): -425251612
reduce(): 705991074

(0+1*1) + (2+3*3) * (2+3*3)

#include <iostream>
#include <vector>
#include <numeric> // for transform_reduce()
#include <execution>
#include <functional>
void printSum(long num)
{
    // 用 1 2 3 4 的 num 个序列创建 coll:
    std::vector<long> coll;
    coll.reserve(num * 4);
    for (long i=0; i < num; ++i) {
        coll.insert(coll.end(), {1, 2, 3, 4});
    }
    auto sum = std::transform_reduce(std::execution::par,
                                     coll.begin(), coll.end(),
                                     0L,
                                     std::plus{},
                                     [] (auto val) {
                                         return val * val;
                                     });
    std::cout << "transform_reduce(): " << sum << '\n';
}
int main()
{
    printSum(1);
    printSum(1000);
    printSum(1000000);
    printSum(10000000);
}

#include <vector>
#include <iostream>
#include <numeric> // for transform_reduce()
#include <execution> // 对于执行策略
#include <filesystem> // filesystem library
int main(int argc, char* argv[])
{
    // 根目录作为命令行参数被传递:
    if (argc < 2) {
        std::cout << "Usage: " << argv[0] << " <path> \n";
        return EXIT_FAILURE;
    }
    std::filesystem::path root{argv[1]};
    // 在通过的文件树中启动所有文件路径的列表:
    std::vector<std::filesystem::path> paths;
    try {
        std::filesystem::recursive_directory_iterator dirpos{root};
        std::copy(begin(dirpos), end(dirpos),
                  std::back_inserter(paths));
    }
    catch (const std::exception& e) {
        std::cerr << "EXCEPTION: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    // 累积所有常规文件的大小:
    auto sz = std::transform_reduce(
        std::execution::par, // 并行执行
        paths.cbegin(), paths.cend(), // range
        std::uintmax_t{0}, // 初始值
        std::plus<>(), // accumulate ...
        [](const std::filesystem::path& p) { // 如果是普通文件，文件大小
            return is_regular_file(p) ? file_size(p)
                : std::uintmax_t{0};
        });
    std::cout << "size of all " << paths.size()
        << " regular files: " << sz << '\n';
}

std::filesystem::path root{argv[1]};
std::vector<std::filesystem::path> paths;
std::filesystem::recursive_directory_iterator dirpos{root};
std::copy(begin(dirpos), end(dirpos),
std::back_inserter(paths));

auto sz = std::transform_reduce(
    std::execution::par, // 并行执行
    paths.cbegin(), paths.cend(), // range
    std::uintmax_t{0}, // initial value
    std::plus<>(), // accumulate ...
    [](const std::filesystem::path& p) { // 文件大小（如果是常规文件）
        return is_regular_file(p) ? file_size(p)
            : std::uintmax_t{0};
    });

std::size_type idx = text.find(sub)。

auto pos = std::search(text.begin(), text.end(),
sub.begin(), sub.end())。

auto pos = std::search(std::execution::par,
text.begin(), text.end(), sub.begin(), sub.end()）。

auto pos = std::search(text.begin(), text.end(),
std::default_searcher{sub.begin(), sub.end()})。

auto pos = std::search(text.begin(), text.end(),
std::boyer_moore_searcher{sub.begin(), sub.end()}）。

auto pos = std::search(text.begin(), text.end(),
std::boyer_moore_horspool_searcher{sub.begin(),
sub.end()}）。

std::boyer_moore_searcher bm{sub.begin(), sub.end()};
for (auto pos = std::search(text.begin(), text.end(), bm);
pos != text.end();
pos = std::search(pos+sub.size(), text.end(), bm)) {
std::cout << "Found '" << sub << "' at index " << pos - text.begin() << '\n';
}

std::boyer_moore_searcher bm{sub.begin(), sub.end()};
...;
for (auto begend = bm(text.begin(), text.end());
     begend.first != text.end();
     begend = bm(begend.second, text.end())) {
    std::cout << "found '" << sub << "' at index "
        << begend.first - text.begin() << '-'
        << begend.second - text.begin() << '\n';
}

std::boyer_moore_searcher bm{sub.begin(), sub.end()};
...;
for (auto [beg, end] = bm(text.begin(), text.end());
     beg != text.end();
     std::tie(beg,end) = bm(end, text.end())) {
    std::cout << "found '" << sub << "' at index "
        << beg - text.begin() << '-'
        << end - text.begin() << '\n';
}

std::boyer_moore_searcher bm{sub.begin(), sub.end()};
...;
if (auto [beg, end] = bm(text.begin(), text.end()); beg != text.end()) {
    std::cout << "found '" << sub << "' first at index "
        << beg - text.begin() << '-'
        << end - text.begin() << '\n';
}

std::vector<int> coll;
...;
std::deque<int> sub{0, 8, 15, ...};
pos = std::search(coll.begin(), coll.end(),
                  std::boyer_moore_searcher{sub.begin(), sub.end()});

std::vector<int> coll;
...;
std::deque<int> sub{0, 8, 15, ...};
std::boyer_moore_searcher bm{sub.begin(), sub.end()};
auto [beg, end] = bm(coll.begin(), coll.end());
if (beg != coll.end) {
    std::cout << "found subsequence at << " beg - coll.begin() << '\n';
}

std::boyer_moore_searcher bmic{substr.begin(), substr.end(),
                             [](char c){
                                 return std::hash<char>{}(std::toupper(c));
                             },
                             [](char c1, char c2){
                                 return std::toupper(c1)==std::toupper(c2);
                             }
                            };
auto begend = bmic(sub.begin(), sub.end());

class Customer {
  ...;
  public:
  Customer() = default;
  std::string getID() const {
      return id;
  }
  friend bool operator== (const Customer& c1, const Customer& c2) {
      return c1.id == c2.id;
  }
};

std::vector<Customer> customers;
...;
std::vector<Customer> sub{...};
...;
std::boyer_moore_searcher bmcust(sub.begin(), sub.end(),
                               [](const Customer& c) {
                                   return std::hash<std::string>{}(c.getID());
                               });
auto pos = bmcust(customers.begin(), customers.end());
if (pos.first != customers.end()) {
  ...;
}

#ifndef LAST5_HPP
#define LAST5_HPP
#include <iterator>
#include <iostream>
template<typename T>
void printLast5(const T& coll)
{
    // 计算大小:
    auto size{std::size(coll)};
    // 前进到从最后 5 个元素开始的位置
    std::cout << size << " elems: ";
    auto pos{std::begin(coll)};
    if (size > 5) {
        std::advance(pos, size - 5);
        std::cout << "... ";
    }
    // 打印剩余元素:
    for ( ; pos != std::end(coll); ++pos) {
        std::cout << *pos << ' ';
    }
    std::cout << '\n';
}
#endif // LAST5_HPP

auto size{std::size(coll)};

std::array arr{27, 3, 5, 8, 7, 12, 22, 0, 55};
std::vector v{0.0, 8.8, 15.15};
std::initializer_list<std::string> il{"just", "five", "small", "string",
                                      "literals"};
printLast5(arr);
printLast5(v);
printLast5(il);

9 elems: ... 7 12 22 0 55
3 elems: 0 8.8 15.15
5 elems: just five small string literal

printLast5("hello world");

12 elems: ... o r l d

#define ARRAYSIZE(a) (sizeof(a)/sizeof(*(a)))

template<typename T>
void printLast5(const std::initializer_list<T>& coll)

if (std::empty(coll)) {
    return;
}

#ifndef DATA_HPP
#define DATA_HPP
#include <iterator>
#include <iostream>
template<typename T>
void printData(const T& coll)
{
    // 每隔一个元素打印一次:
    for (std::size_t idx{0}; idx < std::size(coll); ++idx) {
        if (idx % 2 == 0) {
            std::cout << std::data(coll)[idx] << ' ';
        }
    }
    std::cout << '\n';
}
#endif // DATA_HPP

std::array arr{27, 3, 5, 8, 7, 12, 22, 0, 55};
std::vector v{0.0, 8.8, 15.15};
std::initializer_list<std::string> il{"just", "five", "small", "string",
                                      "literals"};
printData(arr);
printData(v);
printData(il);
printData("hello world");

27 5 7 22 55
0 15.15
just small literals
h l o w r d

std::vector<std::string> coll;
foo(coll); // 喜欢非常量重载
foo(std::as_const(coll)); // 强制使用 const 重载

std::vector<int> coll {8, 15, 7, 42};
auto printColl = [&coll = std::as_const(coll)] {
    std::cout << "coll: ";
    for (int elem : coll) {
        std::cout << elem << ' ';
    }
    std::cout << '\n';
};

printColl();

#include <iostream>
#include <algorithm> // for sample()
int main()
{
    for (int i : {-7, 0, 8, 15}) {
        std::cout << std::clamp(i, 5, 13) << '\n';
    }
}

5
5
8
13

namespace std {
    template<typename T>
    constexpr const T& clamp(const T& value, const T& min, const T& max);
}

double d{4.3};
int max{13};
...
std::clamp(d, 0, max); // 编译时错误
std::clamp<double>(d, 0, max); // OK

for (int i : {-7, 0, 8, 15}) {
    std::cout << std::clamp(i, 5, 13,
                            [] (auto a, auto b) {
                                return std::abs(a) < std::abs(b);
                            })
        << '\n';
}

-7
5
8
13

#include <iostream>
#include <vector>
#include <string>
#include <iterator>
#include <algorithm> // for clamp()
#include <random> // for default_random_engine
int main()
{
    // 初始化一个包含 10,000 个字符串值的vector:
    std::vector<std::string> coll;
    for (int i=0; i < 10000; ++i) {
        coll.push_back("value" + std::to_string(i));
    }
    // 打印此集合的 10 个随机选择的值:
    sample(coll.begin(), coll.end(),
           std::ostream_iterator<std::string>{std::cout, "\n"},
           10,
           std::default_random_engine{});
}

// 打印此集合的 10 个随机选择的值:
sample(coll.begin(), coll.end(),
       std::ostream_iterator<std::string>{std::cout, "\n"},
       10,
       std::default_random_engine{});

value0
value488
value963
value1994
value2540
value2709
value2835
value3518
value5172
value7996

namespace std {
    template<typename InputIterator, typename OutputIterator,
    typename Distance, typename UniformRandomBitGenerator>
        OutputIterator sample(InputIterator sourceBeg, InputIterator sourceEnd,
                              OutputIterator destBeg,
                              Distance num,
                              UniformRandomBitGenerator&& eng);
}

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm> // for clamp()
#include <random> // for default_random_engine
int main()
{
    // initialize a vector of 10,000 string values:
    std::vector<std::string> coll;
    for (int i=0; i < 10000; ++i) {
        coll.push_back("value" + std::to_string(i));
    }
    // 使用随机种子初始化 Mersenne Twister 引擎:
    std::random_device rd; // 随机种子（如果支持）
    std::mt19937 eng{rd()}; // Mersenne twister engine
    // 初始化目标范围（必须足够大以容纳 10 个元素）:
    std::vector<std::string> subset;
    subset.resize(100);
    // 将 10 个随机选择的值从源范围复制到目标范围:
    auto end = sample(coll.begin(), coll.end(),
                      subset.begin(),
                      10,
                      eng);
    // 打印提取的元素（使用返回值作为新的结束）:
    for_each(subset.begin(), end,
             [] (const auto& s) {
                 std::cout << "random elem: " << s << '\n';
             });
}

// 用一个随机种子初始化一个Mersenne Twister引擎:
std::random_device rd; // 随机种子（如果支持）
std::mt19937 eng{rd()}; // Mersenne Twister引擎 

// 初始化目标范围（必须足够大以容纳 10 个元素）:
std::vector<std::string> subset;
subset.resize(100);

// 将 10 个随机选择的值从源范围复制到目标范围:
auto end = sample(coll.begin(), coll.end(),
                  subset.begin(),
                  10,
                  eng);

// 打印提取的元素（使用返回值作为新的结束）：
for_each(subset.begin(), end,
         [] (const auto& s) {
             std::cout << "random elem: " << s << '\n';
         });

#include <iostream>
#include <vector>
#include <string>
#include <algorithm> // for for_each_n()
int main()
{
    // 初始化一个包含 10,000 个字符串值的vector:
    std::vector<std::string> coll;
    for (int i=0; i < 10000; ++i) {
        coll.push_back(std::to_string(i));
    }
    // 修改前 5 个元素：
    for_each_n(coll.begin(), 5,
               [] (auto& elem) {
                   elem = "value" + elem;
               });
    // 打印前 10 个元素：
    for_each_n(coll.begin(), 10,
               [] (const auto& elem) {
                   std::cout << elem << '\n';
               });
}

for_each_n(coll.begin(), 5,
           [] (auto& elem) {
               elem = "value" + elem;
           });

for_each_n(coll.begin(), 10,
           [] (const auto& elem) {
               std::cout << elem << '\n';
           });

value0
value1
value2
value3
value4
5
6
7
8
9

namespace std {
    template<typename InputIterator, typename Size, typename Function>
    InputIterator for_each_n(InputIterator first, Size n, Function f);
}

struct Node
{
    std::string value;
    std::vector<Node> children; // 好的，因为 C++17（节点在这里是不完整的类型）
};

#ifndef NODE_HPP
#define NODE_HPP
#include <vector>
#include <iostream>
#include <string>
class Node
{
private:
    std::string value;
    std::vector<Node> children; // 好的，因为 C++17（节点在这里是不完整的类型）
public:
    // 创建一个带值的节点:
    Node(std::string s) : value{std::move(s)}, children{} {
    }
    // 添加子节点:
    void add(Node n) {
        children.push_back(std::move(n));
    }
    // 访问子节点:
    Node& operator[](std::size_t idx) {
        return children.at(idx);
    }
    // 递归打印节点树:
    void print(int indent = 0) const {
        std::cout << std::string(indent, ' ') << value << '\n';
        for (const auto& n : children) {
            n.print(indent+2);
        }
    }
    ...;
};
#endif // NODE_HPP

#include "incomplete.hpp"
#include <iostream>
int main()
{
    // 创建节点树:
    Node root{"top"};
    root.add(Node{"elem1"});
    root.add(Node{"elem2"});
    root[0].add(Node{"elem1.1"});
    // print node tree:
    root.print();
}

top
elem1
elem1.1
elem2

std::map<int, std::string> m{{1,"mango"},
                             {2,"papaya"},
                             {3,"guava"}};

auto nh = m.extract(2); // nh 的类型为 decltype(m)::node_type
nh.key() = 4;
m.insert(std::move(nh));

std::multimap<double, std::string> src {{1.1,"one"},
                                        {2.2,"two"},
                                        {3.3,"three"}};
std::map<double, std::string> dst {{3.3,"old data"}};
// 将一些元素从 multimap src 移动到 map dst:
dst.insert(src.extract(src.find(1.1))); // 使用迭代器拼接
dst.insert(src.extract(2.2)); // 使用键拼接

auto [pos,done,node] = dst.insert(src.extract(3.3));
if (!done) {
    std::cout << "insert() of node handle failed:"
        << " tried to insert key '" << node.key()
        << "' with value '" << node.mapped()
        << "' but key exists with value '" << pos->second << "'\n";
}

#include <mutex>
...;
std::vector<std::string> allIssues;
std::mutex allIssuesMx;
std::vector<std::string> openIssues;
std::timed_mutex openIssuesMx;
// lock both issue lists:
{
    std::scoped_lock lg(allIssuesMx, openIssuesMx)
    ...; // 操作 allIssues 和 openIssues
}

// 锁定两个问题清单:
{
	std::lock(allIssuesMx, openIssuesMx); // 避免死锁的锁
	std::lock_guard<std::mutex> lg1(allIssuesMx, std::adopt_lock);
	std::lock_guard<std::mutex> lg2(openIssuesMx, std::adopt_lock);
	... // 同时操作allIssues和openIssues
}

// 锁定两个问题清单:
{
	std::lock(allIssuesMx, openIssuesMx); // 注意：使用的死锁避免算法
	std::scoped_lock lg(std::adopt_lock, allIssuesMx, openIssuesMx);
	... // 同时操作allIssues和openIssues
}

#include <shared_mutex>
#include <mutex>
...
std::vector<double> v; // 共享资源
std::shared_mutex vMutex; // 控制对 v 的访问（C++14 中的 shared_timed_mutex）

if (std::shared_lock sl(vMutex); v.size() > 0) {
    ... // （共享）对vector v 元素的读取访问
}

{
    std::scoped_lock sl(vMutex);
    ... // 对vector 的独占写读访问
}

if constexpr(std::atomic<int>::is_always_lock_free) {
    ...
}
else {
    ...
}

if constexpr(atomic<T>::is_always_lock_free) {
    static_assert(atomic<T>().is_lock_free()); // 从未失败
}

if constexpr(std::atomic<int>::is_always_lock_free) {
    // ATOMIC_INT_LOCK_FREE == 2
    ...
}
else {
    // ATOMIC_INT_LOCK_FREE == 0 || ATOMIC_INT_LOCK_FREE == 1
    ...
}

template<auto SZ>
struct Data {
    bool set;
    int values[SZ];
    double average;
};
if constexpr(std::atomic<Data<4>>::is_always_lock_free) {
    ...
}
else {
    ...
}

namespace std {
    inline constexpr size_t hardware_destructive_interference_size;
    inline constexpr size_t hardware_constructive_interference_size;
}

struct Data {
    alignas(std::hardware_destructive_interference_size) int valueForOneThread;
    alignas(std::hardware_destructive_interference_size) int valueForAnotherThread;
};

struct Data {
    int valueForOneThread;
    int valueForTheSameThread;
};
// 仔细检查，由于共享缓存线，我们有最好的性能。
static_assert(sizeof(Data) <= std::hardware_constructive_interference_size);
// 确保对象被正确对齐。
alignas(sizeof(Data)) Data myDataForAThread;