#include <vector>
#include <algorithm>
#include <execution>

int main()
{
    std::vector<int> coll;
    coll.reserve(10000);
    for (int i = 0; i < 10000; ++i) {
        coll.push_back(i);
    }

    std::for_each(std::execution::par,
        coll.begin(), coll.end(),
        [](auto& val) {
            val *= val;
        });
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <thread>
int main()
{
    std::vector<int> coll;
    coll.reserve(10000);
    for (int i = 0; i < 10000; ++i) {
        coll.push_back(i);
    }

    std::for_each(std::execution::par,
        coll.begin(), coll.end(),
        [](auto& val) {
            std::cout << std::this_thread::get_id() << std::endl;
            val *= val;
        });
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <thread>
int main()
{
    std::vector<int> coll;
    coll.reserve(10000);
    for (int i = 0; i < 10000; ++i) {
        coll.push_back(i);
    }

    std::sort(std::execution::par,
        coll.begin(), coll.end(),
        [](const auto& val1, const auto& val2) {
            std::cout << std::this_thread::get_id() << std::endl;
            return val1 > val2;
        });
}

#include <iostream>
#include <chrono>
#include <vector>
#include <algorithm>
#include <execution>

int main()
{
    std::vector<int> coll;
    coll.reserve(100000);
    for (int i = 0; i < 100000; ++i) {
        coll.push_back(i);
    }

    auto start = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::par,
        coll.begin(), coll.end(),
        [](const auto& val1, const auto& val2) {
            return val1 > val2;
        });
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "elapsed time = " << diff.count();
}

struct SomeData { 
  // ... 
  void* user_data; 
};

SomeData sd{};
sd.user_data = new std::string{ "hello world" };

std::string *str = static_cast<std::string *>(sd.user_data);
delete str;
str = nullptr;

struct SomeData {
    // ... 
    std::shared_ptr<void> user_data;
};

SomeData sd{};
sd.user_data = std::make_shared<std::string>("hello world");

auto ud = std::static_pointer_cast<std::string>(sd.user_data);

struct any {
 void* object;
 type_info tinfo;
};

#include <iostream>
#include <string>
#include <any>

int main()
{
    std::any a;
    a = std::string{ "hello world" };
    auto str = std::any_cast<std::string>(a);
    std::cout << str;
}

auto& str1 = std::any_cast<std::string&>(a);
auto& str2 = std::any_cast<const std::string&>(a);

try {
    std::cout << std::any_cast<double>(a) << "\n";
}
catch (const std::bad_any_cast&) {
    std::cout << "Wrong Type!";
}

auto* ptr = std::any_cast<std::string>(&a);
if(ptr) {
 std::cout << *ptr;
} else {
 std::cout << "Wrong Type!";
}

const type_info* const _Info = _TypeInfo();
if (!_Info || *_Info != typeid(_Decayed)) {
    return nullptr;
}

template <class T>
void destroy_impl(void* const p)
{
    delete static_cast<T*>(p);
}

using destory_ptr = void (*)(void* const);

struct AnyMetadata {
    destory_ptr func;
    ...
};

template<class T>
void create_anymeta(AnyMetadata &meta)
{
    meta.func = destroy_impl<T>;
}

// any构造时知道目标对象类型，此时可以保存函数指针
AnyMetadata metadata;
create_anymeta<std::string>(metadata);

// any销毁时调用
metadata.func(obj);

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <random>
int main()
{
    std::vector<int> data;
    for (int i = 0; i < 10000; ++i) {
        data.push_back(i);
    }

    std::sample(data.begin(), 
        data.end(),
        std::ostream_iterator<int>{std::cout, "\n"},
        10,
        std::default_random_engine{});
}

std::random_device rd;
std::default_random_engine eng{ rd() };
std::sample(data.begin(), 
    data.end(),
    std::ostream_iterator<int>{std::cout, "\n"},
    10,
    eng);

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <random>
int main()
{
    std::vector<int> data;
    for (int i = 0; i < 10000; ++i) {
        data.push_back(i);
    }

    std::vector<int> out_data;
    out_data.resize(100);
    std::random_device rd;
    std::default_random_engine eng{ rd() };
    auto end = std::sample(data.begin(), 
        data.end(),
        out_data.begin(),
        10,
        eng);

    std::cout << "coll size: " 
        << out_data.size() 
        << std::endl;
    for (auto it = out_data.begin(); it != end; ++it) {
        std::cout << *it << std::endl;
    }
}

coll size: 100
1708
1830
2803
3708
5146
7376
7867
8059
8271
9448

template<int _Nx>
struct _MyPh
{
};

constexpr _MyPh<0> _0;
constexpr _MyPh<1> _1;
constexpr _MyPh<2> _2;
constexpr _MyPh<3> _3;
constexpr _MyPh<4> _4;

template<typename R, typename F, typename ... Arg>
class _MyBind {
public:
    _MyBind(F f, Arg ... arg) : _MyList(arg...), _f(f) {}
    template<typename ... CallArg>
    R operator()(CallArg... arg)
    {
        _MyBind<R, F, CallArg...> c(0, arg...);
        std::size_t constexpr tSize 
            = std::tuple_size<std::tuple<Arg...>>::value;
        return call_tuple(_f, _MyList, 
            c, std::make_index_sequence<tSize>());
    }

    template<typename F, typename Tuple, typename C, size_t ...S>
    R call_tuple(F f, Tuple t, C c, std::index_sequence<S...>)
    {
        return f(c[std::get<S>(_MyList)]...);
    }

    template<typename T> T operator[] (T &t) { return t; }
    template<int N> typename std::tuple_element<N, 
        std::tuple<Arg...>>::type operator[] (_MyPh<N>) 
    { 
            return std::get<N>(_MyList);
    }
private:
    std::tuple<Arg...> _MyList;
    F _f;
};
template<typename R, typename F, typename ... Arg> 
    _MyBind<R, F, Arg...> mybind(F f, Arg ... arg)
{
    return _MyBind<R, F, Arg...>(f, arg...);
}

int sum(int a, int b, int c)
{
    std::cout << a << b << c;
    return a + b + c;
}

int main()
{
    auto myfunc = mybind<int>(sum, _0, 2, _1)(1, 5);
}

void set_data(int *arr, int len) {}

int main()
{
    int buf[128]{ 0 };
    set_data(buf, 128);
}

#include <iostream>
#include <span>
void set_data(std::span<int> arr) {
    std::cout << arr.size();
}

int main()
{
    int buf[128]{ 0 };
    set_data(buf);
}

std::vector<int> buf1{ 1,2,3 };
std::array<int, 3> buf2{ 1, 2, 3 };
set_data(buf1);
set_data(buf2);

int buf[128]{ 0 };
set_data({ buf, 16 });

#include <iostream>
#include <chrono>
#include <string_view>

template <class T>
struct tokenizer {
    using string_type = T;
    using value_type = typename T::value_type;
    tokenizer(const string_type& str, 
        std::enable_if_t<std::disjunction_v<
        std::is_same<string_type, std::basic_string<value_type>>,
        std::is_same<string_type, std::basic_string_view<value_type>>>>* = nullptr)
        : data_(str), begin_(0), end_(0) {}
    string_type operator()(const value_type sep) {
        for (; end_ < data_.size(); ++end_) {
            if (data_[end_] == sep) {
                auto res = data_.substr(begin_, end_ - begin_);
                begin_ = ++end_;
                return res;
            }
        }
        if (end_ <= data_.size()) {
            return data_.substr(begin_, end_);
        }

        return "";
    }
    bool more() const { return end_ < data_.size(); }
private:
    const string_type data_;
    size_t begin_, end_;
};

std::string make_string_data(size_t count, char sep) {
    std::string data;
    for (size_t i = 0; i < count; ++i) {
        data.push_back('a' + i % 26);
        if (i + 1 != count)
            data.push_back(sep);
    }
    return data;
}

int main()
{
    std::string data = make_string_data(1024 * 1024 * 32, ' ');

    tokenizer<std::string> tk(data);
    auto start = std::chrono::high_resolution_clock::now();
    while (tk.more())
    {
        tk(' ');
    }

    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end - start;
    std::cout << "elapsed time = " << diff.count();
}

#include <memory>

int main()
{
    std::shared_ptr<int> pt1{ new int{ 10 } };
    auto pt2{ pt1 };
}

#include <memory>

int main()
{
    auto pt{ new int{ 10 } };
    std::shared_ptr<int> pt1{ pt };
    std::shared_ptr<int> pt2{ pt };
}

struct SomeData;
void SomeAPI(const std::shared_ptr<SomeData>& d) {}

struct SomeData {
    void NeedCallSomeAPI() {
        // 需要用this调用SomeAPI
    }
};

struct SomeData {
    void NeedCallSomeAPI() {
        SomeAPI(std::shared_ptr<SomeData>{this});
    }
};

#include <memory>

struct SomeData;
void SomeAPI(const std::shared_ptr<SomeData>& d) {}

struct SomeData:std::enable_shared_from_this<SomeData> {
    static std::shared_ptr<SomeData> Create() {
        return std::shared_ptr<SomeData>(new SomeData);
    }
    void NeedCallSomeAPI() {
        SomeAPI(shared_from_this());
    }
private:
    SomeData() {}
};


int main()
{
    auto d{ SomeData::Create() };
    d->NeedCallSomeAPI();
}

template<class T>
class enable_shared_from_this {
 mutable weak_ptr<T> weak_this;
public:
 shared_ptr<T> shared_from_this() {
  return shared_ptr<T>(weak_this); 
 }
 shared_ptr<const T> shared_from_this() const {
  return shared_ptr<const T>(weak_this); 
 }
...
 template <class U> friend class shared_ptr;
};

#include <memory>

struct SomeData;
void SomeAPI(const std::shared_ptr<SomeData>& d) {}

struct SomeData:std::enable_shared_from_this<SomeData> {
    void NeedCallSomeAPI() {
        SomeAPI(shared_from_this());
    }

};


int main()
{
    auto d{ new SomeData };
    d->NeedCallSomeAPI();
}

template <class _Ty>
class enable_shared_from_this { 
public:
    using _Esft_type = enable_shared_from_this;
    ...
}

template <class _Yty, class = void>
struct _Can_enable_shared : false_type {};

template <class _Yty>
struct _Can_enable_shared<_Yty, void_t<typename _Yty::_Esft_type>>
    : is_convertible<remove_cv_t<_Yty>*, typename _Yty::_Esft_type*>::type {
};

template <class _Ux>
   void _Set_ptr_rep_and_enable_shared(_Ux* const _Px, _Ref_count_base* const _Rx) noexcept {
       this->_Ptr = _Px;
       this->_Rep = _Rx;
       if constexpr (conjunction_v<negation<is_array<_Ty>>, negation<is_volatile<_Ux>>, _Can_enable_shared<_Ux>>) {
           if (_Px && _Px->_Wptr.expired()) {
               _Px->_Wptr = shared_ptr<remove_cv_t<_Ux>>(*this, const_cast<remove_cv_t<_Ux>*>(_Px));
           }
       }
   }

#include <iostream>
#include <fmt/core.h>

int main()
{
    std::cout << fmt::format("{} {}", "hello", "world");
}

#include <iostream>
#include <fmt/core.h>

int main()
{
    std::cout << fmt::format("{1} {0} {1}", "hello", "world");
}

#include <iostream>
#include <fmt/core.h>
#include <fmt/format.h>

int main()
{
    using namespace fmt::literals;
    std::cout << fmt::format(
        "{first} {second}", 
        "first"_a = "hello", "second"_a = "world");
}

#include <iostream>
#include <fmt/core.h>

int main()
{
    std::cout << fmt::format("{:.2f}", 3.1415926);
}

#include <iostream>
#include <fmt/core.h>

struct PersonInfo
{
    char name[16];
    int age;
    char telephone[16];
};

template<> struct fmt::formatter<PersonInfo> {

    constexpr fmt::format_parse_context::iterator 
    parse(fmt::format_parse_context& ctx) {
        auto iter = ctx.begin();
        return ++iter;
    }

    fmt::format_context::iterator 
    format(PersonInfo info, fmt::format_context& ctx) {
        return fmt::format_to(ctx.out(), 
        "name : {} | age : {} | tel. : {}", 
        info.name, info.age, info.telephone);
    }
};

int main()
{
    PersonInfo info{ "xiaoming", 18, "1234567890" };
    std::cout << fmt::format("{}", info);
}