#prama once
#include "this_file_own_header.h"   // 自己对应的头文件

#include <cstdio>                   // C 标准库
#include <string>                   // C++ 标准库
#include <vector>

#include "other_project_header.h"   // 其他项目的头
#include "myproject/util/logging.h" // 自己项目的其他模块

namespace Jill{
    double bucket(double n){ ... }
    double fetch;
    int pal;
    struct Hill{ ... };
} // 命名空间可以定义变量，函数，类型。

namespace Jill{ // 可以命名同样名称的命名空间，但是最后会合并成同一个。
  void fuck;
}

namespace outer{
  namespace inter{
    
  }
} // 可以嵌套
namespace outer::inter{} // 等效于上面

// 全局变量真实写法
int g = 42;
void f();

// 逻辑上可以想象成：
namespace /* global */ { // cpp 有个隐式的名称空间，被成为全局名称空间，同名字意思。
    int g = 42;
    void f();
}

int main(){
  ::f(); // 所以可以用:: 指是全局函数
}

void a(){
    using std::cout;
    cout << 1;
}
int main(){
    a();//cout 可以
    cout << 1;//cout 不可以
}

namespace{
  xxx;
}

union U{
public: // C++ 添加了访问权限
  
private:

protected:
}

#include <iostream>
#include <string>
#include <variant>

// 小工具：把多个 lambda 组合成一个“重载访问器”
template<class... Ts>
struct overloaded : Ts... {
    using Ts::operator()...;
};
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

int main() {
    // 1. std:: variant：类型安全的“联合体”（union 替代品）
    //    这里 v 可以存 int / double / std:: string 其中之一
    std::variant<int, double, std::string> v;

    v = 42;                 // 现在 v 里是 int
    std::cout << std::get<int>(v) << "\n";  // 取出 int

    v = 3.14;               // 现在 v 里是 double
    std::cout << std::get<double>(v) << "\n";

    v = std::string("hi");  // 现在 v 里是 std:: string
    std::cout << std::get<std::string>(v) << "\n";

    // 安全访问：get_if 返回指针，类型不匹配则返回 nullptr
    if (const int* pi = std::get_if<int>(&v)) {
        std::cout << "It's int: " << *pi << "\n";
    } else {
        std::cout << "It's not int\n";      // 这里会走这条
    }

    // 2. std:: visit：根据当前实际类型调用合适的处理逻辑
    // 2.1 用结构体访问器
    struct Visitor {
        void operator()(int i) const {
            std::cout << "int: " << i << "\n";
        }
        void operator()(double d) const {
            std::cout << "double: " << d << "\n";
        }
        void operator()(const std::string& s) const {
            std::cout << "string: " << s << "\n";
        }
    };

    v = 123;
    std::visit(Visitor{}, v);          // 根据当前类型是 int，调用 Visitor:: operator()(int)

    v = std::string("world");
    std::visit(Visitor{}, v);          // 当前是 string，调用 string 重载

    // 2.2 更常用写法：lambda + overloaded
    std::variant<int, double, std::string> v2 = 3.14;

    auto printer = overloaded{
        [](int i)               { std::cout << "lambda int: "    << i << "\n"; },
        [](double d)            { std::cout << "lambda double: " << d << "\n"; },
        [](const std::string& s){ std::cout << "lambda string: " << s << "\n"; }
    };

    std::visit(printer, v2);           // 输出：lambda double: 3.14

    // 3. std:: visit 有返回值：由所有重载的“共同返回类型”决定
    std::variant<int, std::string> v3 = "OK";

    auto make_msg = overloaded{
        [](int i) {
            return std::string("from int: ") + std::to_string(i);
        },
        [](const std::string& s) {
            return std::string("from string: ") + s;
        }
    };
    std::string r = std::visit(make_msg, v3);
    std::cout << r << "\n";            // 输出：from string: OK

    // 4. 多个 variant 一起 visit：处理组合情况
    std::variant<int, float> v4 = 10;
    std::variant<long, float> v5 = 2.5f;

    auto combiner = overloaded{
        // 泛型版本：处理 (int, long) 以外的任意组合
        [](auto a, auto b) {
            std::cout << "sum: " << (a + b) << "\n";
        },
        // 特例：专门处理 (int, long)
        [](int i, long l) {
            std::cout << "int + long: " << (i + l) << "\n";
        }
    };

    std::visit(combiner, v4, v5);      // 当前 (int, float) → 调用泛型 lambda
    v5 = long{20};
    std::visit(combiner, v4, v5);      // 当前 (int, long) → 调用专门的 (int, long) 重载

    return 0;
}

// 解决作用域问题
enum class Color { Red, Green };
enum class TrafficLight { Red, Green, Yellow };
Color c = Color::Red;
TrafficLight t = TrafficLight::Red;
// 解决隐式转化问题
Color c = Color::Red;
int x = c;          // 编译错误：不能隐式转成 int
c = 1;              // 编译错误：不能用整数给 enum class 赋值
// 指定底层类型
enum class Color : unsigned char {
    Red,
    Green,
    Blue
};

template<typename T>
void f(T&& param);                  //param 是一个通用引用

auto&& var2 = var1;                 //var2 是一个通用引用

void process(const Widget& lvalArg);        //处理左值
void process(Widget&& rvalArg);             //处理右值

template<typename T>                        //用以转发 param 到 process 的模板
void logAndProcess(T&& param)
{
    auto now =                              //获取现在时间
        std::chrono::system_clock::now();
    
    makeLogEntry("Calling 'process'", now);
    process(std::forward<T>(param));
}

struct HandleDeleter {
    // 告诉 unique_ptr，你管理的“指针”类型其实是 HANDLE
    using pointer = HANDLE;
    void operator()(HANDLE handle) const {
        if (handle && handle != INVALID_HANDLE_VALUE) {
            CloseHandle(handle);
        }
    }
};

// T 是 HANDLE, Deleter 是 HandleDeleter
// 因为 HandleDeleter:: pointer 存在, 所以 UniqueHandle 内部的指针类型是 HANDLE，而不是 HANDLE*
// 否则编译不通过。
using UniqueHandle = std::unique_ptr<HANDLE, HandleDeleter>;

double a = 1.1;
const int &b = (int)a; // 大多数的解释是 a 被转化后, 是把转化值放入一个临时常量, 把这个常量赋值, 所以 b 必须用 const 来修饰。

int harpo(int n,int m=4,int j=5);
//VALID
int chico(int n,int m=6,int j);
//INVALID
int groucho(int k=1,int m=2,int n=3);
//VALID

[捕获列表](参数列表) mutable(可选) 异常属性 -> 返回类型 {/*函数体*/}

#include <iostream>

int main() {
    int x = 10;
    
    // 不使用 mutable：按值捕获的 x 是 const，无法修改
    auto func1 = [x]() {
        // x = 20;  // 错误：不能修改按值捕获的变量
        std::cout << "func1: " << x << std::endl;
    };
    
    // 使用 mutable：允许修改按值捕获的 x 副本
    auto func2 = [x]() mutable {
        x = 20;  // 合法：修改的是副本，不影响外部 x
        std::cout << "func2 内部: " << x << std::endl;
    };
    
    func1();  // 输出：func1: 10
    func2();  // 输出：func2 内部: 20
    std::cout << "外部 x: " << x << std::endl;  // 输出：外部 x: 10（原变量未变）
    return 0;
}

#include <functional>
#include <iostream>

int foo(int para) {
    return para;
}

int main() {
    // std:: function 包装了一个返回值为 int, 参数为 int 的函数
    std::function<int(int)> func = foo;

    int important = 10;
    std::function<int(int)> func2 = [&](int value) -> int {
        return 1+value+important;
    };
    std::cout << func(10) << std::endl;
    std::cout << func2(10) << std::endl;
}

void foo(int a, int b, int c) {
    std::cout << a << b << c << std::endl;
}
int main() {
    // 将参数 1,2 绑定到函数 foo 上，
    // 但使用 std::placeholders::_1 来对第一个参数进行占位
    auto bindFoo = std::bind(foo, std::placeholders::_1, std::placeholders::_2,2);
    auto bindFoo_ = std::bind(foo, std::placeholder::_2, std::placerholders::_1, 2);
    // 这时调用 bindFoo 时，只需要提供第一个参数即可
    bindFoo(1,2);// 输出 122
    bindFoo_(1,2); // 输出 212
}

class w{int add(int a, int b){return a+b;}};
w w1;
auto add1 = std::bind(&w::add, &w, 10, 1)//第一个参数的引用必须保留, 第二个参数必须是类对象, 等于说代替 this 指针.

auto L = [](int x){f1(f2())}; //这里只是封装, 没用调用 f2()
auto B = std::bind(f1, f2, _1); //这里会调用 f2 来传递, 正确写法看下面
auto B = std::bind(f1, std::bind(f2), _1);

void foo(int a);
void foo(int a, int b);

auto L = [](int b){foo(1, b)};
auto B = std::bind(foo, 1, b);//报错, 除非对 foo 强制类型转化

Box operator+(const Box&);

Box operator+(const Box&, const Box&);

void Stock::updata(double price)

class Rectangle {
private:
    int width;
    int height;
public:
    // 带参数的普通构造函数
    Rectangle(int w, int h) : width(w), height(h) {} 
    // 不带参数的普通构造函数（默认构造函数的一种形式）
    Rectangle() : width(0), height(0) {} 
    int getArea() const {
        return width * height;
    }
};

class Point {
private:
    int x;
    int y;
public:
    // 用户自定义的默认构造函数
    Point() : x(0), y(0) {} 
};
//下面是没有生成构造函数的例子
class Circle {
private:
    double radius;
};
// 编译器自动生成的默认构造函数大致等价于：
// Circle:: Circle() {
//     // 对基本类型成员，默认值不确定，对类类型成员，会调用其默认构造函数
// } 

class Student {
private:
    std::string name;
    int age;
public:
    Student(const std::string& n, int a) : name(n), age(a) {}
    // 自定义拷贝构造函数
    Student(const Student& other) : name(other.name), age(other.age) {} 
    //编译器会生成的类型
};

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r) : real(r), imag(0) {}
    // 委托构造函数，调用上面的单参数构造函数
    Complex(double r, double i) : Complex(r) { 
        imag = i;
    }
};
//Complex(double r, double i)构造函数委托 Complex(double r)构造函数先初始化 real 成员，然后再初始化 imag 成员。

class Integer {
private:
    int value;
public:
    // 转换构造函数，将 int 转换为 Integer 对象
    Integer(int num) : value(num) {} 
    int getValue() const {
        return value;
    }
};

Integer num = 10;  // 隐式调用转换构造函数，将 int 10 转换为 Integer 对象

class Magic {
    public:
    Magic() = default; // 显式声明使用编译器生成的构造
    Magic& operator=(const Magic&) = delete; // 显式声明拒绝编译器生成构造
    Magic(int magic_number);
} 

class Point {
public:
    int x;
    int y;
    Point() = default;  // 使用编译器生成的默认构造函数
};

int main() {
    Point p;  // 默认初始化，x 和 y 值不确定（这里使用默认构造函数）
    return 0;
}

class Rectangle {
public:
    int width;
    int height;
    Rectangle(int w = 0, int h = 0) : width(w), height(h) {}
};

int main() {
    Rectangle r1();  // 值初始化，等价于 Rectangle r1(0, 0);
    Rectangle r2{};  // 值初始化，width 和 height 被初始化为 0
    int arr[3]{};  // 值初始化，数组元素都为 0
    return 0;
}

class Circle {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double getArea() const {
        return 3.14 * radius * radius;
    }
};

int main() {
    Circle c(5.0);  // 直接初始化，调用 Circle(double r)构造函数
    return 0;
}

class Student {
private:
    std::string name;
    int age;
public:
    Student(const std::string& n, int a) : name(n), age(a) {}
    Student(const Student& other) : name(other.name), age(other.age) {}
};

int main() {
    Student s1("Alice", 20);
    Student s2 = s1;  // 拷贝初始化，调用拷贝构造函数
    return 0;
}

class Person {
private:
    std::string name;
    int age;
public:
    Person(const std::initializer_list<int>& list) {
        if (list.size() == 2) {
            age = *list.begin();
            // 这里假设简单转换，实际中可能需要更复杂逻辑
            name = std::to_string(*(list.begin() + 1)); 
        }
    }
    Person(const std::string& n, int a) : name(n), age(a) {}
};

int main() {
    Person p1{"Bob", 25};  // 列表初始化，调用 Person(const std:: string&, int)构造函数
    Person p2{28, 3};  // 列表初始化，调用 Person(const std:: initializer_list <int>&)构造函数
    return 0;
}

class Time {
private:
    int hour;
    int minute;
    int second;
public:
    Time(int h) : hour(h), minute(0), second(0) {}
    Time(int h, int m) : Time(h) {  // 委托 Time(int h)构造函数
        minute = m;
    }
    Time(int h, int m, int s) : Time(h, m) {  // 委托 Time(int h, int m)构造函数
        second = s;
    }
};

class father{...};

class son:public father{
    ...
};
//father 为父类, public 代表继承关系, 可以继承多个类.

template class std::vector<bool>;          // 强行实例化
extern template class std::vector<double>; // 不在该当前编译文件中实例化模板

template 返回类型 名字 < 实参列表 > ( 形参列表 ) ;         // (1)
template 返回类型 名字 ( 形参列表 ) ;                     // (2)
extern template 返回类型 名字 < 实参列表 > ( 形参列表 ) ;  // (3) (C++11 起)
extern template 返回类型 名字 ( 形参列表 ) ;              // (4) (C++11 起)

template 类关键词 模板名 < 实参列表 > ;       //  (1)   
extern template 类关键词 模板名 < 实参列表 > ;//  (2)(C++11 起)

std::vector<std::vector<int>> matrix;

template<bool T>
class MagicType {
    bool magic = T;
};

// in main function:
std::vector<MagicType<(1>2)>> magic; // 合法, 但不建议写出这样的代码

template <typename AnyType>
void Swap(AnyType &a, AnyType &b){
    AnyType temp;
    temp = a;
    a = b;
    b = temp;
}
//template < 形参列表 > 函数声明

template<typename... Ts> class Magic;

class Magic<int,
            std::vector<int>,
            std::map<std::string,
            std::vector<int>>> darkMagic;

template<typename Require, typename... Args> class Magic;

template<typename... Args> void printf(const std::string &str, Args... args);//Args 为模板类型包, args 为参数包, 分别存储类型和值, 名字可更换

template<typename... Ts>
void magic(Ts... args) {
    std::cout << sizeof...(args) << std::endl;
}

magic(); // 输出 0
magic(1); // 输出 1
magic(1, ""); // 输出 2

#include <iostream>
template<typename T0>
void printf1(T0 value) {
    std::cout << value << std::endl;
}//如果不写, 那么下面的就会出现输出一个空参数的 printf1, 但是我们没有实现, 故而会报错.
template<typename T, typename... Ts>
void printf1(T value, Ts... args) {
    std::cout << value << std::endl;
    printf1(args...);
}
int main() {
    printf1(1, 2, "123", 1.1);
    return 0;
}

template<typename T0, typename... T>
void printf2(T0 t0, T... t) {
    std::cout << t0 << std::endl;
    if constexpr (sizeof...(t) > 0) printf2(t...); //注意这是编译期的事情, 所以不能简单用 if 解决, 故而 17 才成功了.
}

template<typename T, typename... Ts>
auto printf3(T value, Ts... args) {
    std::cout << value << std::endl;
    (void) std::initializer_list<T>{([&args] {
        std::cout << args << std::endl;
    }(), value)...};
}

#include <iostream>
template<typename ... T>
auto sum(T ... t) {
    return (t + ...);//此处则是...的另一个用法, 不过核心还是展开参数
}
int main() {
    std::cout << sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) << std::endl;
}
( 形参包 运算符 ... )              (1)
( ... 运算符 形参包 )              (2)
( 形参包 运算符 ... 运算符 初值 )   (3)
( 初值 运算符 ... 运算符 形参包 )   (4)

#include <iostream>

// 一元右折叠：(a + ...) 相当于 a1 + (a2 + (a3 + ...))
template<typename... Args>
auto sum_right(Args... args) {
    return (args + ...);
}

int main() {
    std::cout << sum_right(1, 2, 3, 4) << std::endl;  // 1+(2+(3+4))= 10
    return 0;
}

// 一元左折叠：(... * a) 相当于 (((a1 * a2) * a3) * ...)
template<typename... Args>
auto product_left(Args... args) {
    return (... * args);
}

int main() {
    std::cout << product_left(1, 2, 3, 4) << std::endl;  // ((1 *2)* 3)*4 = 24
    return 0;
}

// 二元右折叠：(a + ... + 10) 相当于 a1 + (a2 + (a3 + 10))
template<typename... Args>
auto sum_right_with_init(Args... args) {
    return (args + ... + 10);
}

int main() {
    std::cout << sum_right_with_init(1, 2, 3) << std::endl;  // 1+(2+(3+10))= 16
    return 0;
}

// 二元左折叠：(100 - ... - a) 相当于 (((100 - a1) - a2) - a3)
template<typename... Args>
auto subtract_left_with_init(Args... args) {
    return (100 - ... - args);
}

int main() {
    std::cout << subtract_left_with_init(10, 20, 30) << std::endl;  // ((100-10)-20)-30 = 40
    return 0;
}

template<typename T = int>
void f();

f();            // 默认为 f <int>
f<double>();    // 显式指明为 f <double>

using namespace std::string_literals;

template<typename T1,typename T2,typename RT = 
    decltype(true ? T1{} : T2{}) >
RT max(const T1& a, const T2& b) { // RT 是 std:: string
    return a > b ? a : b;
}

template <typename T, typename U>
auto add(T t, U u) {
    return t+u;
}

template <typename T, int BufSize>
class buffer_t {
public:
    T& alloc();
    void free(T& item);
private:
    T data[BufSize];
}

buffer_t<int, 100> buf; // 100 作为模板参数

template <auto value> void foo() {
    std::cout << value << std::endl;
    return;
}

int main() {
    foo<10>();  // value 被推导为 int 类型
}

template<typename T>
struct Test{
    Test(T v) :t{ v } {}
private:
    T t;
};

Test(int) -> Test<std::size_t>;

Test t(1);      // t 是 Test <size_t>

template<typename T>
Test(T*) -> Test<T[]>;

char* p = nullptr;

Test t(p);      // t 是 Test <char[]>

template<typename T>
T v; //可以有各种修饰

template<typename T,typename T2>
auto f(const T& a, const T2& b)  {
    return a + b;
}

template<>
auto f(const double& a, const int& b){
    return a - b;
}

template<>
auto f<double, int>(const double& a, const int& b) {
    return a - b;
}

template<typename T>
const char* s = "?";            // 主模板

template<typename T>
const char* s<T*> = "pointer";  // 偏特化，对指针这一类类型

template<typename T>
const char* s<T[]> = "array";   // 偏特化，但是只是对 T [] 这一类类型，而不是数组类型，因为 int [] 和 int [N] 不是一个类型

std::cout << s<int> << '\n';            // ?
std::cout << s<int*> << '\n';           // pointer
std::cout << s<std::string*> << '\n';   // pointer
std::cout << s<int[]> << '\n';          // array
std::cout << s<double[]> << '\n';       // array
std::cout << s<int[1]> << '\n';         // ?

template<typename T>
void func() {
    // T:: type 是待决名，必须用 typename 声明它是类型
    typename T::type value;  // 正确：告诉编译器 T:: type 是类型
    // T:: type value;       // 错误：编译器会以为 type 是变量
}

// 测试用的类型
struct MyType {
    using type = int;  // 这里 type 是类型别名
};

int main() {
    func<MyType>();  // 实例化后，T:: type 就是 int
    return 0;
}
#include <vector>

template<typename T>
void print(const std::vector<T>& v) {
    // std:: vector <T>:: iterator 是待决名，必须加 typename
    typename std::vector<T>::iterator it = v.begin();  // 正确
    // std:: vector <T>:: iterator it;  // 错误：编译器不认它是类型
}

template<typename T>
struct MyStruct {
    template<typename U>
    void foo(U x) {  // 成员函数模板
        cout << x << endl;
    }
};

template<typename T>
void call_foo() {
    MyStruct<T> s;
    // s.foo <int>(5);       // 错误：编译器会把 < 当成小于号
    s.template foo<int>(5);  // 正确：用 template 声明 foo 是模板
}

int main() {
    call_foo<int>();  // 输出 5
    return 0;
}
template<typename T>
struct Container {
    template<typename U>
    using SubType = pair<T, U>;  // 嵌套的模板类型
};

template<typename T>
void test() {
    // 访问 Container <T> 的嵌套模板 SubType
    typename Container<T>::template SubType<double> data;  // 正确
    // 解释：
    // 1. typename：声明 Container <T>:: SubType 是类型
    // 2. template：声明 SubType 是模板（需要传入 double）
}

#include <iostream>

// 全局函数
void print(int x) { cout << "全局print: " << x << endl; }

template<typename T>
struct Base {
    void print(int x) { cout << "Base::print: " << x << endl; }
};

template<typename T>
struct Derived : Base<T> {
    void call_print() {
        print(1);  // 非待决名：定义时绑定到全局 print
        this->print(2);  // 待决名：实例化时找 Base <T> 的 print
    }
};

int main() {
    Derived<int> d;
    d.call_print();
    // 输出：
    // 全局 print: 1
    // Base::print: 2
    return 0;
}

#include <iostream>

// 模板 1：要求 T 必须有 type 成员
template<typename T>
void func(typename T::type) {
    std::cout << "T有type成员" << std::endl;
}

// 模板 2：通用版本
template<typename T>
void func(T) {
    std::cout << "通用版本" << std::endl;
}

struct HasType { using type = int; };
struct NoType {};

int main() {
    func<HasType>(1);  // 调用模板 1：HasType 有 type
    func<NoType>(2);   // 调用模板 2：NoType 无 type，模板 1 代换失败但不报错
    return 0;
}
//输出:
//T 有 type 成员
//通用版本

#include <type_traits>

// 只有 T 是 int 时才启用这个函数
template<typename T>
std::enable_if_t<std::is_same_v<T, int>, void>
print(T x) {
    std::cout << "int: " << x << std::endl;
}

// 只有 T 是 double 时才启用这个函数
template<typename T>
std::enable_if_t<std::is_same_v<T, double>, void>
print(T x) {
    std::cout << "double: " << x << std::endl;
}

int main() {
    print(10);      // 匹配 int 版本
    print(3.14);    // 匹配 double 版本
    // print("hi"); // 无匹配版本，编译错误
    return 0;
}

#include <type_traits>

// 检查 T 是否有 size()成员函数
template<typename T, typename = void>
struct HasSize : std::false_type {};

template<typename T>
struct HasSize<T, std::void_t<decltype(std::declval<T>().size())>> 
    : std::true_type {};

// 测试
#include <vector>
#include <iostream>

int main() {
    std::cout << HasSize<std::vector<int>>::value << std::endl; // 1（有 size()）
    std::cout << HasSize<int>::value << std::endl;              // 0（无 size()）
    return 0;
}

#include <type_traits>

// 检查 T 是否有 operator+，即使 T 没有默认构造函数
template<typename T>
struct HasPlus {
    template<typename U>
    static auto check(U u) -> decltype(u + u, std::true_type{});
    static std::false_type check(...);
    
    static constexpr bool value = decltype(check(std::declval<T>()))::value;
};

struct A { int operator+(A) { return 0; } };
struct B { B(int) {} int operator+(B) { return 0; } }; // 无默认构造

int main() {
    std::cout << HasPlus<A>::value << std::endl; // 1（A 有+且可默认构造）
    std::cout << HasPlus<B>::value << std::endl; // 1（B 有+，用 declval 避开构造）
    return 0;
}

template<typename T>
concept Add = requires(T a) {
    a + a; // "需要表达式 a+a 是可以通过编译的有效表达式"
};

template<Add T>
auto add(const T& t1, const T& t2){
    std::puts("concept +");
    return t1 + t2;
}

std::cout << std::boolalpha << Add<int> << '\n';        // true
std::cout << std::boolalpha << Add<char[10]> << '\n';   // false
constexpr bool r = Add<int>;                            // true

decltype(auto) max(const auto& a, const auto& b)  { // const T&
    return a > b ? a : b;
}

#include <concepts> // C++20 概念库标头

decltype(auto) max(const std::integral auto& a, const std::integral auto& b) {
    return a > b ? a : b;
}

max(1, 2);     // OK
max('1', '2'); // OK
max(1u, 2u);   // OK
max(1l, 2l);   // OK
max(1.0, 2);   // Error! 未满足关联约束

template< class T >
concept integral = std::is_integral_v<T>;

template<typename T>
concept add = requires(T t) {
    t + t;
};

template<typename T>
    requires std::is_same_v<T, int>
void f(T){}

template<typename T> requires add<T>
void f2(T) {}

template<typename T>
void f3(T)requires requires(T t) { t + t; }
{}

template<typename T>
    requires true
void f(T){}

template<class T>
concept Integral = std::is_integral_v<T>;
template<class T>
concept SignedIntegral = Integral<T> && std::is_signed_v<T>;
template<class T>
concept UnsignedIntegral = Integral<T> && !SignedIntegral<T>;

template<typename T>
concept number = std::integral<T> || std::floating_point<T>;

void f(const number auto&){}

f(1);      // OK 
f(1u);     // OK 
f(1.2);    // OK 
f(1.2f);   // OK 
f("1");    // 未找到匹配的重载函数

auto add14 = [](auto x, auto y) -> int {
    return x+y;
}

auto add20(auto x, auto y) {
    return x+y;
//编译器自动生成一堆模板.    
auto i = 5; // type int
auto j = 6; // type int
std::cout << add14(i, j) << std::endl;
std::cout << add20(i, j) << std::endl;

int a = 10;
double b = 100.1;
decltype (a+b) c = a + b;
//decltype 可以推导表达式结果的类型, 虽然这里用 auto 也可以啦.

template<typename T, typename U>
auto add2(T x, U y) -> decltype(x+y){
    return x + y;
}