auto f = [](const auto& x) // 参数使用auto声明，泛型化
{
    return x + x;
};
cout << f(3) << endl;     // 参数类型是int
cout << f(0.618) << endl; // 参数类型是double
string str = "matrix";
cout << f(str) << endl;   // 参数类型是string

class LambdaClosure {
public:
    LambdaClosure(int captured_value, const int& captured_reference)
        : captured_value(captured_value), captured_reference(captured_reference) {}

    int operator()(int x, int y) const {
        return x + y + captured_value + captured_reference;
    }

private:
    int captured_value;
    const int& captured_reference;
};

int main() {
    int captured_value = 10;
    int captured_reference = 15;

    auto lambda_captured = [captured_value, &captured_reference](int x, int y) -> int {
        return x + y + captured_value + captured_reference;
    };

    int result_lambda = lambda_captured(3, 5); // 调用 lambda 表达式
    int result_closure = LambdaClosure(captured_value, captured_reference)(3, 5); // 调用转化后的类的 operator() 方法

    std::cout << "Result from lambda: " << result_lambda << std::endl;
    std::cout << "Result from closure: " << result_closure << std::endl;

    return 0;
}

# [capture](parameters)->return-type{body}
[外部变量访问方式说明符(=|&)] (参数表) -> 返回值类型
{
   语句块
}
[](int x, int y) -> int { int z = x + y; return z + x; }
[]        // 沒有定义任何变量。使用未定义变量会引发错误。
[x, &y]   // x以传值方式传入（默认），y以引用方式传入。
[&]       // 全部引用捕获
[=]       // 全部值捕获
[&, x]    // x显式值捕获
[=, &z]   // z显式引用捕获
[this]    // 捕获对象的this指针

int main()
{
    int x = 100,y=200,z=300;
    auto ff = [=,&y,&z](int n) {  // x是值传递，y和z是引用传递
        cout <<x << endl;
        y++; z++;
        return n*n;
    };
    cout << ff(15) << endl;
    cout << y << "," << z << endl;
}

class Example
{
public:
    Example() : m_var(10) {}
    void func()
    {
        [=]()
        { std::cout << m_var << std::endl; }(); //立即调用
    }

private:
    int m_var;
};
int main()
{
    Example e;
    e.func();
}

// 编译的时候用到这个函数的地方会报警告
[[deprecated("deadline:2020-12-31")]] // C++14 or later
int old_func();

[[gnu::unused]] // 声明下面的变量暂不使用，不是错误
int nouse;

template<int N>
struct fib
{
    static_assert(N >= 0, "N >= 0");
    static const int value =
        fib<N - 1>::value + fib<N - 2>::value;
};

// 假设T是一个模板参数，即template<typename T>
static_assert(
    is_integral<T>::value, "int");
static_assert(
    is_pointer<T>::value, "ptr");
static_assert(
    is_default_constructible<T>::value, "constructible");

#include <iostream> 
#include <tuple>
 
using namespace std;
 
template<int... N>
decltype(auto) fun(index_sequence<N...> is) {
    return make_tuple(N...);
}
 
int main() {
 
    auto t = fun(make_index_sequence<3>());
    cout << std::get<0>(t) << endl;
    cout << std::get<1>(t) << endl;
    cout << std::get<2>(t) << endl;
    return 0;
}

template <int N, int... Ns>
auto sum()
{
    if constexpr (0 == sizeof...(Ns))
        return N;
    else
        return N + sum<Ns...>();
}

// 调用
sum<1, 2, 3>(); // returns 6

A* p = new A(10);
shared_ptr <A> sp1(p), sp2(p);

unique_ptr<string> ptr2(new string("hello")); // string智能指针
assert(*ptr2 == "hello"); // 可以使用*取内容
assert(ptr2->size() == 5); // 可以使用->调用成员函数

ptr1++; // 导致编译错误
ptr2 += 2; // 导致编译错误

unique_ptr<int> ptr3; // 未初始化智能指针
*ptr3 = 42 ; // 错误！操作了空指针

auto ptr3 = make_unique<int>(42); // 工厂函数创建智能指针
assert(ptr3 && *ptr3 == 42);
auto ptr4 = make_unique<string>("god of war"); // 工厂函数创建智能指针
assert(!ptr4->empty());

template<class T, class... Args> // 可变参数模板
std::unique_ptr<T> // 返回智能指针
my_make_unique(Args&&... args) // 可变参数模板的入口参数
{
    return std::unique_ptr<T>( // 构造智能指针
        new T(std::forward<Args>(args)...)); // 完美转发
}

auto ptr1 = make_shared<int>(42);       // 工厂函数创建智能指针
assert(ptr1 && ptr1.unique() );         // 此时智能指针有效且唯一
auto ptr2 = ptr1;                            // 直接拷贝赋值，不需要使用move()
assert(ptr1 && ptr2);                        // 此时两个智能指针均有效
assert(ptr1 == ptr2);                        // shared_ptr可以直接比较
// 两个智能指针均不唯一，且引用计数为2
assert(!ptr1.unique() && ptr1.use_count() == 2);
assert(!ptr2.unique() && ptr2.use_count() == 2);

operator=()   //重载 = 赋值运算符，是的 weak_ptr 指针可以直接被 weak_ptr 或者 shared_ptr 类型指针赋值。
swap(x)      // 其中 x 表示一个同类型的 weak_ptr 类型指针，该函数可以互换 2 个同类型 weak_ptr 指针的内容。
reset()    // 将当前 weak_ptr 指针置为空指针。
use_count()  //查看指向和当前 weak_ptr 指针相同的 shared_ptr 指针的数量。
expired()  // 判断当前 weak_ptr 指针为否过期（指针为空，或者指向的堆内存已经被释放）。
lock()     // 如果当前 weak_ptr 已经过期，则该函数会返回一个空的 shared_ptr 指针；反之，该函数返回一个和当前 weak_ptr 指向相同的 shared_ptr 指针。

class Node final
{
public:
    using this_type = Node;
    using shared_type = std::shared_ptr<this_type>;
public:
    shared_type next; // 使用智能指针来指向下一个节点
};

auto n1 = make_shared<Node>(); // 工厂函数创建智能指针
auto n2 = make_shared<Node>(); // 工厂函数创建智能指针

assert(n1.use_count() == 1); // 引用计数为1
assert(n2.use_count() == 1);
n1->next = n2; // 两个节点互指，形成了循环引用
n2->next = n1;
assert(n1.use_count() == 2); // 引用计数为2
assert(n2.use_count() == 2); 
// 出作用域析构时n1减1，n2减1，但因彼此都相互引用，所以无法减到0

class Node final
{
public:
    using this_type = Node;
    // 注意这里，别名改用weak_ptr
    using shared_type = std::weak_ptr<this_type>;
public:
    shared_type next; // 因为用了别名，所以代码不需要改动
};
auto n1 = make_shared<Node>(); // 工厂函数创建智能指针
auto n2 = make_shared<Node>(); // 工厂函数创建智能指针
n1->next = n2; // 两个节点互指，形成了循环引用
n2->next = n1;
assert(n1.use_count() == 1); // 因为使用了weak_ptr，引用计数为1
assert(n2.use_count() == 1); // 打破循环引用，不会导致内存泄漏
if (!n1->next.expired()) { // 检查指针是否有效
    auto ptr = n1->next.lock();   // lock()获取shared_ptr
    assert(ptr == n2);
}

class Base final { // 声明 Base 类为最终类
    virtual void foo() const final; // foo() 不能在派生类中重写
};

class NoCopy {
public:
    NoCopy() = default;
    NoCopy(const NoCopy&) = delete; // 禁用拷贝构造函数
};

class Base {
public:
    virtual void foo();
};

class Derived : public Base {
public:
    void foo() override; // 显式声明 foo() 是对基类虚函数的重写
};

enum Color {black, white, red};

#define black 0
#define white 1
#define red 2

enum Shape {circle,retangle};
auto circle = 10;  // error

#define circle 0
#define retangle 1

enum A {a,b};
enum B {c,a};

// 在创建枚举时，将它们放在名称空间中，以便可以使用有意义的名称访问它们:
namespace EntityType {enum Enum {
        Ground = 0,
        Human,
        Aerial,
        Total
    };
}


void foo(EntityType::Enum entityType)
{
    if (entityType == EntityType::Ground) {
        /*code*/
    }
}

// enum class
enum class EntityType {
    Ground = 0,
    Human,
    Aerial,
    Total
};

void foo(EntityType entityType)
{
    if (entityType == EntityType::Ground) {
        /*code*/
    }
}

#include <iostream>
#include <string>
enum class Color:int {red,green,blue};
enum class Font:char {normal,bold};
int main()
{
    Color c;
    std::cout<<sizeof(c)<<std::endl;  //输出为  4

    Font f;
    std::cout<<sizeof(f)<<std::endl;  //输出为  1
}

bool div_int(int a, int b, int &result) {
    if (b == 0) {
        return false;
    }
    result = a / b;
    return true;
}

//div_int可以通过optional优化：optional中，结果是否有效和结果都保存在其中
std::optional<int> div_int(int a, int b) {
    if (b != 0) {
        return std::make_optional<int>(a / b);
    }
    return {};
}


TEST_F(optional) {
    auto ret = div_int(2, 1);
    ASSERT(ret);
    ASSERT_EQ(2, ret.value()); // 如果ret为true, 直接从ret中获取结果


    auto ret2 = div_int(2, 0);
    ASSERT(!ret2); // 结果无效

    // 如果ret2为false，获取访问value将会 抛出异常
    try {
        ret2.value();
    } catch (std::exception e) {
        std::cout << e.what() << std::endl;
    }
}

class A{};
A & rl = A(); //错误，无名临时变量 A() 是右值，因此不能初始化左值引用 r1
A && r2 = A(); //正确，因 r2 是右值引用

std::vector<int> v1;
v1.push_back(1);
v1.push_back(2);

// Move the contents of v1 to v2 using move semantics
std::vector<int> v2 = std::move(v1);

struct Foo {
    Foo(int n, double x);
};

std::vector v;
v.emplace_back(42, 3.1416);     // 没有临时变量产生
v.insert(someIterator, Foo(42, 3.1416)); // 需要产生一个临时变量
v.insert(someIterator, {42, 3.1416});    // 需要产生一个临时变量

std::map<int, std::string> myMap;
myMap.emplace(1, "one");  // 构造一个键值对并插入

template <typename T>
void function(T&& t) {
    otherdef(forward<T>(t));
}

int main()
{
    int a = 10;
    const int & con_b = a;
    cout << con_b << endl;
    a = 20;
    cout << con_b << endl;
}

map<string, complex> scp;
scp.emplace(“hello”, 1, 2);

map<string, complex<double>> scp;
scp.emplace(piecewise_construct,
    forward_as_tuple("hello"),
    forward_as_tuple(1, 2));

scp.insert({"world", {1, 2}});

class MyClass {
public:
    // 成员变量类内初始化
    int value1 = 0;
    double value2 = 3.14;
    std::string text = "Hello";

    // 构造函数
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
};

int x = 10; // 使用传统初始化方式
int y{20};  // 使用统一初始化语法

struct Point {
    int x;
    int y;
};

Point p = {2, 3}; // 聚合类型初始化
Point q{4, 5};    // 统一初始化语法

std::vector<int> nums = {1, 2, 3}; // 使用统一初始化初始化容器
std::vector<int> nums{1, 2, 3}; // 使用统一初始化初始化容器

std::string str{"Hello, World!"};  // 使用统一初始化初始化字符串

#include <iostream>

class MyClass {
public:
    // 委托构造函数,调用本类的两个参数的构造函数
    MyClass() : MyClass(0, 0) {
        std::cout << "Default constructor" << std::endl;
    }
    // 委托构造函数,调用本类的两个参数的构造函数
    MyClass(int value) : MyClass(value, 0) {
        std::cout << "Single-argument constructor" << std::endl;
    }

    MyClass(int value1, int value2) : memberValue1(value1), memberValue2(value2) {
        std::cout << "Two-argument constructor" << std::endl;
    }

    void PrintValues() {
        std::cout << "Values: " << memberValue1 << ", " << memberValue2 << std::endl;
    }

private:
    int memberValue1;
    int memberValue2;
};

class Base {
public:
    Base(int value) : baseValue(value) {}
    void showValue() {
        std::cout << "Base value: " << baseValue << std::endl;
    }
private:
    int baseValue;
};

class Derived : public Base {
public:
    using Base::Base; // 继承基类的构造函数
    void showDerivedValue() {
        std::cout << "Derived value: " << baseValue * 2 << std::endl;
    }
};

int main() {
    Derived derivedObj(5);
    derivedObj.showValue();         // 调用基类的成员函数
    derivedObj.showDerivedValue();  // 调用派生类的成员函数

    return 0;
}

using uint_t = unsigned int; // using别名
typedef unsigned int uint_t； // 等价的typedef

int i;
double t;
struct A { double x; };
const A* a = new A();
decltype(a) x1; //x1 是 A*
decltype(i) x2; //x2 是 int
decltype(a->x) x3; // x3 是 double

// std::tie 返回一个元组，其中包含了从输入参数中提取的元素的**引用**
// std::tie 用于引入字典序比较到结构体
struct S {
    int n;
    std::string s;
    float d;
    bool operator<(const S& rhs) const {
        // 比较 n 与 rhs.n,
        // 而后为 s 与 rhs.s,
        // 而后为 d 与 rhs.d
        return std::tie(n, s, d) < std::tie(rhs.n, rhs.s, rhs.d);
    }
};

// 通过tie将tuple中的元素解构至多个变量中  
auto student = std::make_tuple(3.8, 'A', "Lisa Simpson");
double gpa1;
char grade1;
std::string name1;
std::tie(gpa1, grade1, name1) = student;

bool result;
std::tie(std::ignore, result) = set.insert(value);

template <typename... Types>
std::tuple<Types&...> tie(Types&... args) {
    return std::tuple<Types&...>(args...);
}

using IntFloatString = std::variant<int, float, std::string>; // 定义支持int、float、string三个类型，并取一个别名
//初始化一个variant
TEST_F(InitVariant) {

    IntFloatString i = 10;
    ASSERT_EQ(10, std::get<int>(i) );
    ASSERT_EQ(10, std::get<0>(i) );
    std::cout << i.index(); // prints   0，  即第几个位置设置了值

    IntFloatString f = 20.0f;
    ASSERT_EQ(20.0f, std::get<float>(f) );

    IntFloatString s = "hello world";
    ASSERT_EQ("hello world", std::get<std::string>(s));
}

//before
void isKeyword(const std::string & lit){
    work();
}
//after
void isKeyword(std::string_view lit){
    work();
}

string_view sv("123456789");
sv.remove_suffix(1);    // 现在sv中为：12345678, sv的大小为8
sv.remove_prefix(2);    // 现在sv中为: 345678, sv的大小为6

string_view foo() {
    std::string s{"hello world"};
    return string_view{s};
}

void printLength(std::string_view sv) {
    std::cout << "Length of string: " << sv.length() << std::endl;
}

int main() {
    std::string s1 = "Hello, world!";
    char s2[] = "C++ is great!";
    const char* s3 = "Programming is fun!";

    // 传递不同类型的字符串给 printLength 函数
    printLength(s1);  // 使用 std::string
    printLength(s2);  // 使用字符数组
    printLength(s3);  // 使用字符串指针
    printLength("Short");  // 使用字符串字面值

    return 0;
}

//before
auto*tmp = parseExpression();
if(tmp!=nullptr){
    work();
}
//after   
 if (auto* tmp = parseExpression(); tmp != nullptr) {
    work();
}

std::tuple<int,string> nextToken(){
    return {4,"fallthrough"};
}

//before
int main() {
    auto token = nextToken();
    std::cout<<std::get<int>(token)<<","<<std::get<std::string>(token);
    return 0;
}
//after
int main() {
    auto[tokenType,lexeme] = nextToken();
    std::cout<<tokenType<<","<<lexeme;
    return 0;
}