第十三號艦隊

// my_std.h
void foo(int);
void bar(void);
// other_lib.h
int foo(void);
int baz(int, int);

// my_std.h
void my_std_foo(int);
void my_std_bar(void);
// other_lib.h
int other_lib_foo(void);
int other_lib_baz(int, int);

// my_std.h
namespace my_std {
	void foo(int);
	void bar(void);
}
// other_lib.h
namespace other_lib {
	int foo(void);
	int baz(int, int);
}

namespace A
{
    struct Empty {};
    void foo(int) {}
    void bar(Empty, int) {}
}

void func()
{
    A::foo(2);
    bar(A::Empty{}, 1);
    std::cout << 1; // operator<< (std::cout, 1) Due to ADL
}

std::operator<<(std::cout, 1);

namespace std {
	template<typename T> 
	void swap(T& a, T& b) { 
		T temp(a); 
		a = b; 
		b = temp; 
	}
}

namespace My {
	class A {
	public:
		void swap(A&) {}
	};
}

```cpp
namespace std
{
    template<>
    void swap<::My::A>(::My::A& a, ::My::A& b) {a.swap(b);}
}

template<>
void std::swap<My::A>(My::A& a, My::A& b) { a.swap(b); }

void fun(...); // 1 
namespace My { 
	struct A{}; 
	void fun(const A&); // 2 
}
namespace Code { 
	void fun(int); // 3 
	void use() {
		::My::A a;
		fun(a); // HERE 
	} 
}

#include <utility>
namespace My
{
    struct A
    {
        friend void swap(A& a, A& b) { a.swap(b); }
    };
    template<typename T>
    struct B
    {
        friend void swap(B& a, B& b) { a.swap(b); }
    };
}
namespace Code
{
    void use()
    {
        using std::swap;
        ::My::A a1, a2;
        swap(a1, a2); // HERE #1
        ::My::B<int> b1, b2;
        swap(b1, b2); // HERE #2
        int i1, i2;
        swap(i1, i2); // NOPE
    }
}

using std::swap;
swap(a1, a2);

std::swap(a1, a2);

namespace __my_std_impl
{
    template<typename T>
    auto __distance_impl(T first, T last) {/* ... */}
    template<typename T>
    auto distance(T first, T last) {return __distance_impl(first, last);}
}
struct incomplete;
template<typename T> struct box {T value;};
void use()
{
    incomplete* i = nullptr; // fine
    __my_std_impl::distance(i, i); // fine
    box<incomplete>* b = nullptr; // fine
    __my_std_impl::distance(b, b); // !!!
}

template<typename T>
auto distance(T first, T last) {return __my_std_impl::__distance_impl(first, last);}

namespace std::ranges {
	inline constexpr swap = [](auto& a, auto& b) { 
		using std::swap;
		swap(a, b); 
	};
}

some_ranges | views::transform(ranges::begin)

some_ranges | views::transform(std::begin)

#include <iostream>
#include <type_traits>
namespace mystd
{
    class B{};
    class A{};
    template<typename T>
    void swap(T &a, T &b)
    {
        std::cout << "mystd::swap\n";
    }
}

namespace sx
{
    namespace impl {
       //our functor, the niebloid
        struct __swap {
            template<typename R, typename = std::enable_if_t< std::is_same<R, mystd::A>::value >  >
            void operator()(R &a, R &b) const
            {
                std::cout << "in sx::swap()\n";
                // swap(a, b); 
            }
        };
    }
    inline constexpr impl::__swap swap{};
}

int main()
{
    mystd::B a, b;
    swap(a, b); // calls mystd::swap()

    using namespace sx;
    mystd::A c, d;
    swap(c, d); //No ADL!, calls sx::swap!

    return 0;
}

namespace std::range {
	inline constexpr swap = [](auto& a, auto& b) { 
		using std::swap;
		swap(a, b); 
	};
}
namespace A {
	void swap(...);
}
nameapce B {
	void swap(....);
}

#include <bfg/tag_invoke.h>
namespace compute {
BFG_TAG_INVOKE_DEF(formula);
} // namespace compute

template <typename Compute>
float do_compute(const Compute & c, float a, float b)
{
	return compute::formula(c, a, b);
}

struct custom_compute
{
private:
	friend float
		tag_invoke(compute::formula_t, const custom_compute &, float a, float b)
	{
		return a * b;
	}
};

int main()
{
	do_compute(custom_compute{}, 2, 3);
}

template <typename T>
T min(T a, T b)
{
        return (a < b) ? a : b;
}
template <typename T>
T min(T a, T b, T c)
{
        return (a < b) ? (a < c) ? a : c : (b < c) ? b : c;
}

template <typename T, typename... Args>
T min(const T& first, const Args&... args)
{
        if constexpr (sizeof...(Args) == 0) {
                return first;
        } else {
                const auto minV = min(args...);
                return (first < minV) ? first : minV;
        }
}

#define VL_RESTORER(var) \
    const VRestorer<typename std::decay<decltype(var)>::type> restorer_##var(var);

template <typename T> class VRestorer {
    T& m_ref;
    const T m_saved;
public:
    explicit VRestorer(T& permr)
        : m_ref{permr}
        , m_saved{permr} {}
    ~VRestorer() { m_ref = m_saved; }
};

int a = 1, b = 2;
VL_RESTORER(a);
VL_RESTORER(b);
a = 3;
b = 4;

template <typename F>
struct scope_exit
{
    F f;
    ~scope_exit() { f(); }
};

template <typename F>
inline scope_exit<F> make_scope_exit(F&& f)
{
        return scope_exit<F>{f};
}

template <typename ...Ts>
inline auto restore(Ts&& ...ts)
{
        return [restore_ref = std::tuple<std::add_lvalue_reference_t<std::decay_t<Ts>>...>(std::forward<Ts>(ts)...),
                store = std::tuple<std::add_const_t<std::decay_t<Ts>>...>(ts...)]() mutable noexcept
        {
                        restore_ref = store;
        };
}

int a = 1, b = 2;
auto _ = make_scope_exit(restore(a, b));
a = 3;
b = 4;

struct obj {
    int a;
};

void print(const obj& o)
{
    printf("%d\n", o.a);
}

void print(const obj& o)
{
    printf("a: %d\n", o.a);
}

struct obj1 {
    int a;
    int b;
};

int main() {
    struct obj1 o = { .a=1, .b=2 };
    __builtin_dump_struct(&o, &printf);
    return 0;
}

template <typename T>
void print(const T& o)
{
    for (auto& field : { field of o })
        std::cout << field << "\n";
}

#include <boost/hana.hpp>
struct OrderedItem {
    BOOST_HANA_DEFINE_STRUCT(
            OrderedItem,
            (std::string, item_name),
            (int64_t, quantity),
            (int64_t, price_cents)
    );
};

template<typename T>
boost::json::value FormatStructure(const T &t) {
    boost::json::object result;
    boost::hana::for_each(t, boost::hana::fuse([&result](auto name, auto member) {
        result.emplace(boost::hana::to<const char *>(name), FormatObject(member));
    }));
    return result;
}
template<typename T>
boost::json::value FormatObject(const T &t) {
    if constexpr (boost::hana::Struct<T>::value) {
        return internal::FormatStructure(t);
    } else {
        return internal::FormatValue(t);
    }
}

struct S {
    int b;
    std::string s;
    std::vector<std::string> v;
};
 
// Reflection TS
#include <experimental/reflect>
using meta_S = reflexpr(S);
using mem = std::reflect::get_data_members_t<meta_S>;
using meta = std::reflect::get_data_members_t<mem>;

struct Obj {
	int a, b;
};
std::array<Obj, 100> objs;

std::tuple<std::array<int, 100>, std::array<int, 100>> objs;

int sum = 0;
for (auto v : objs)
	sum += v.a;

int sum = 0;
auto &as = std::get<0>(objs);
for (auto v : as)
	sum += v;

struct Person {
	std::string name;
	int age;
};
std::vector<Person> persons;
std::sort(begin(persons), end(persons), [](const auto& p1, const auto& p2) {
	return p1.name < p2.name;
});

std::ranges::sort(persons, std::ranges::less{}, &Person::name);

template <typename Function, typename Projection>
class projecting_fn {
public:
    projecting_fn(Function function, Projection projection)
        : m_function{ std::move(function) }
        , m_projection{ std::move(projection) }
    {
    }

    template <typename... Args>
    decltype(auto) operator() (Args&&... args) const
    {
        return std::invoke(
            m_function,
            std::invoke(m_projection, std::forward<decltype(args)>(args))...);
    }

private:
    Function m_function;
    Projection m_projection;
};
std::sort(begin(persons), end(persons),
     projecting_fn{ std::less{}, &Person::name });

template<typename T>
struct LessThan
{
    bool operator()(const T& x){
        return x < value;
    }
    T value;
};

struct Apple
{
    int weight;
    int size;
};

int main()
{
    auto apples = std::vector<Apple>{{1,2}, {2,3}, {3,4}};

    auto smallApples = apples | views::filter(LessThan{3}, &Apple::size);
}

apples | views::filter([] (Apple& a) {return a.size < 3;})

apples | views::filter(hof::proj(&Apple::size, LessThan{3}));

export module hello;
export void hello_world() {};
void non_export_func() {}

import hello;
int main()
{
    hello_world(); // OK
    non_export_func(); // Cannot compile
    return 0;
}

export void hello_world() {};
void non_export_func() {}

// export entire namespace
export namespace hello {}

// export the symbols in the block
export {
	int e = 1;
	void test() {}
}

export module hello;
export void hello_world();
void non_export_func();

module hello;
void hello_world() {};
void non_export_func() {}

export module world;
export struct obj {};

export module hello;
import world;
export void hello_world(obj o) {};

import hello;
import world;
int main()
{
        obj o;
        hello_world(o);
        return 0;
}

export module hello;
export import world;
export void hello_world(obj o) {};

export module hello.sub_a;
export void hello() {};

export module hello;
export import hello.sub_a;
export import hello.sub_b;

import hello.sub_a;
import hello.sub_b;
int main()
{
        hello();
        world();
        return 0;
}

export module hello:part_a;
export void hello() {};

export module hello;
export import :part_a;
export import :part_b;

module;
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#include <string>
#include <vector>
export module hello;

socket.async_connect(endpoint, [](std::error_code ec) {
	// blablabla
});

asio::io_context ctx;
asio::ip::tcp::socket socket(ctx);
auto future = socket.async_connect(endpoint, asio::use_future);
std::thread t([&] {
	ctx.run();
});
future.get();

asio::awaitable<void> timeout(std::chrono::seconds seconds)
{
	asio::steady_timer timer(co_await asio::this_coro::executor);
	timer.expires_after(seconds);
	co_await timer.async_wait(use_nothrow_awaitable);
}

asio::awaitable<std::error_code> connect_with_timeout(
	asio::ip::tcp::socket& socket,
	const asio::ip::tcp::endpoint& endpoint)
{
	using namespace asio::experimental::awaitable_operators;
	auto result = co_await(
		socket.async_connect(endpoint, use_nothrow_awaitable) ||
		timeout(std::chrono::seconds(5))
	);
	if (result.index() == 1) {
		co_return asio::error::timed_out; // timed out
	}
	auto [r] = std::get<0>(result);
	co_return r;
}

asio::io_context io_context;
auto connect_future = asio::co_spawn(
    io_context.get_executor(),
	connect_with_timeout(asio::ip::tcp::socket(io_context), endpoint), 
	asio::use_future);
io_context.run();
return connect_future.get();