第十三號艦隊

#include <iostream>
#include <string>
struct Test {
        int index;
        std::string name;
        void printInfo() const {
                std::cout << "index: " << index << ", name: " << name << "\n";
        }
};
int main()
{
        Test test;
        test.index = 1;
        test.name = "test_1";
        test.printInfo();
        auto index_addr = &Test::index;
        auto name_addr = &Test::name;
        auto fun_print_addr = &Test::printInfo;
        test.*index_addr = 2;
        test.*name_addr = "test_2";
        (test.*fun_print_addr)();
        return 0;
};

struct X
{
    int m1;
    int m2;
};
BOOST_DESCRIBE_STRUCT(X, (), (m1, m2))

class MyClass
{
public:
	int field = 0;
	static int static_field;
	void method();
	static void static_method();
};

reflang::Class<MyClass> metadata;
MyClass c;

// Modify / use c's 'field'.
reflang::Reference ref = metadata.GetField(c, "field");
ref.GetT<int>() = 10;

// Modify / use 'static_field'.
ref = metadata.GetStaticField("static_field")
ref.GetT<int>() = 10;

// Execute 'method()'.
auto methods = metadata.GetMethod("method");
(*methods[0])(c);

// Execute 'static_method()'.
auto methods = metadata.GetStaticMethod("static_method");
(*methods[0])();

template <class T>
void print_type() {
    std::cout << "void "
              << get_name_v<reflexpr(print_type<T>)> // guaranteed "print_type"
              << "() [with T = "
              << get_display_name_v<reflexpr(T)> 
              << "]" << std::endl;
}

struct Value {
	int v;
};

Value v1, v2;
v1 < v2;

struct Value {
	int v;
	bool operator<(const Value &rhs) { return v < rhs.v; }
	bool operator==(const Value &rhs) { return v == rhs.v; }
	// Ignore
};

bool operator<(const Value &lhs, const Value &rhs) { return lhs.v < rhs.v; }
bool operator==(const Value &lhs, const Value &rhs) { return lhs.v == rhs.v; }

bool operator>(const Value &lhs, const Value &rhs);
bool operator==(const Value &lhs, const Value &rhs);
bool operator!=(const Value &lhs, const Value &rhs);

struct Value1 {
    int v;
	int v1;
};

bool operator<(const Value1 &lhs, const Value1 &rhs);
bool operator>(const Value1 &lhs, const Value1 &rhs);
bool operator==(const Value1 &lhs, const Value1 &rhs);
bool operator!=(const Value1 &lhs, const Value1 &rhs);

template<class Derived>
struct Equality {
        bool operator !=(const Equality &rhs) {
                return !(static_cast<Derived&>(*this) == static_cast<const Derived&>(rhs));
        }
};

struct Value : Equality<Value> {
        int v;
        bool operator==(const Value &rhs) const { return v == rhs.v; }
};

struct Value1 : Equality<Value1> {
		int v;
        int v1;
        bool operator==(const Value1 &rhs) const { return v == rhs.v; && v1 == rhs.v1; }
};

#include <compare>
struct Value {
        int v;
        auto operator<=>(const Value&) const = default; (1)
};

(a <=> b) < 0  //true if a < b
(a <=> b) > 0  //true if a > b
(a <=> b) == 0 //true if a is equal/equivalent to b

struct Value1 {
	int v;
	int v1;
public:
	auto operator<=>(const Value1& rhs) const {
	   if (auto cmp = v <=> rhs.v; cmp != 0)
		   return cmp;
		return v1 <=> rhs.v1;
	}
 }
};

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