const int * const p3 = p2 // 靠右的const是顶层const，靠左的是底层const

int main() {
    int a = 3, b = 4;
    const int* p1 = &a;  // 指向 const int 的指针（数据不可改，但指针可改）
    
    // *p1 = 5;  // ❌ 错误：不能修改 p1 指向的值
    p1 = &b;     // ✅ 可以修改 p1 的指向
    a = 10;      // ✅ 直接修改 a 是允许的
}

constexpr int GetLen(int a, int b)
{
	return a + b;
}

int main()
{
	// 不加constexpr就无法声明arr 加了之后就会返回常数
	int arr[GetLen(1, 2)];
	return 0;
}

private:
    int value;
    void changeValue() const {
        value = 10;  // 编译错误：不能在 const 函数中修改成员变量
    }

void func1(std::vector<int> vec);  // 按值传递，会进行复制
void func2(const std::vector<int>& vec);  // 按引用传递，不会复制

int a = 10;
decltype(a) b = 20;
cout << typeid(b).name() << endl;

int e = 4;
const int* f = &e;
decltype(auto) j = f; // decltype(auto) 会保留引用类型，但 auto 会丢弃引用类型。
cout << typeid(j).name() << endl;

enum class Color {
    Red,
    Green,
    Blue
}; // 等同于
enum class Color : int {
    Red,
    Green,
    Blue
};

class Person
{
public:
	int getAge()
	{
		return age;
	}
	void setAge(int age)
	{
		// 相当于自己赋值给自己 并不是赋值给Person的成员变量
		age = age;
        // this->age = age;
		cout << "age = " << age << endl; // 输出age = 23
	}
    // 或者
    Person setAge(int age)
	{
		this->age = age;
		cout << "age = " << age << endl;
		return *this;
	}
private:
	int age;
};

int main()
{
	Person p;
	p.setAge(23);
	cout << p.getAge(); // 输出随机值
	return 0;
}

// 类内函数
void destroy()
{
	delete this;
}
int main()
{
	Person p;
	p.destroy(); // 会出错，因为在栈空间分配 尝试释放非堆内存是错误的
	return 0;
}

void func(int& a)
{
	cout << "调用左值引用" << a << endl;
}

void func(int&& a)
{
	cout << "调用右值引用" << a << endl;
}

int main()
{
	int a = 10;
	func(20); // 输出：调用右值引用20
	func(a); // 输出：调用左值引用10
	return 0;
}

class Building
{
	friend void goodGuy(Building* building);
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	std::string m_SittingRoom; // 客厅

private:
	std::string m_BedRoom; // 卧室
};

// 全局函数
void goodGuy(Building* building)
{
	std::cout << "好朋友全局函数正在访问：" << building->m_SittingRoom << std::endl;
	std::cout << "好朋友全局函数正在访问：" << building->m_BedRoom << std::endl;
}

int main()
{
	Building building; // 输出：好朋友全局函数正在访问：客厅
	goodGuy(&building);// 输出：好朋友全局函数正在访问：卧室
}

#include<iostream>
using namespace std;

class Person {
public:
	int number;
	int height;
	static char* pool; // 内存池的起始地址

	Person(int number, int height) :number(number), height(height) { cout << "调用构造函数\n"; }
	~Person() { cout << "调用析构函数\n"; }

	static bool initpool() {
		pool = (char*)malloc(18);
		if (pool == 0) return false;
		memset(pool, 0, 18);
		cout << "内存池起始地址是：" << (void*)pool << endl;
		return true;
	}
	static void freepool() {
		if (pool == 0) return;
		free(pool);
		cout << "内存池已释放\n";
	}
	void* operator new(size_t size) {
		if (pool[0] == 0) { // 判断第一块是否空闲
			cout << "分配了第一块内存" << (void*)(pool + 1) << endl;
			pool[0] = 1;
			return pool + 1;
		}
		if (pool[9] == 0) {
			cout << "分配了第二块内存" << (void*)(pool + 9) << endl;
			pool[9] = 1;
			return pool + 9;
		}
		void* ptr = malloc(size);
		cout << "申请到的内存地址是" << ptr << endl;
		return ptr;
	}

	void operator delete(void* ptr) {
		if (ptr == 0) return;
		if (ptr == pool + 1) {
			cout << "释放了第一块内存" << endl;
			pool[0] = 0;
			return; // 立即返回
		}
		if (ptr == pool + 9) {
			cout << "释放了第二块内存" << endl;
			pool[9] = 0;
			return;
		}
		free(ptr); // 释放那些不是在内存池中 系统创建的对象
	}
};

char* Person::pool = 0; // 初始化静态成员变量 内存池指针

int main() {
	if (Person::initpool() == false) {
		cout << "初始化内存池失败\n";
		return -1;
	}
	Person* p2 = new Person(3, 8);
	cout << "p2地址为：" << (void*)p2 << "编号" << p2->number << "身高" << p2->height << endl;
	delete p2;
	Person::freepool();
}

template<class T>
class Base
{
	T m;
};
class Son :public Base{}; // 错误：必须要知道父类中的T类型才能继承给子类
class Son :public Base<int>{}; // 正确

template<class T1, class T2>
class Son2 : public Base<T2>
{
public:
	T1 obj;
	Son2()
	{
        // 声明Son2<int, char> S2;
		std::cout << "T1类型为" << typeid(T1).name() << std::endl; // int
		std::cout << "T2类型为" << typeid(T2).name() << std::endl; // char
	}
};

template <typename T, typename U>
class MyClass
{
public:
	void print()
	{
		cout << "Generic Template" << endl;
	}
};

template<typename T>
class MyClass<T*, int>
{
public:
	void print()
	{
		cout << "Template specialized for pointer types and int" << endl;
	}
};

template<>
class MyClass<char, float>
{
public:
	void print()
	{
		cout << "Template specialized for char and float" << endl;
	}
};

int main()
{
	MyClass<int, float> obj1; // 使用普通模板
	MyClass<int*, int> obj2; // 使用偏特例化
	MyClass<char, float> obj3; // 使用完全特例化模板

	obj1.print(); // 输出 "Generic Template"
	obj2.print(); // 输出 "Template specialized for pointer types and int"
	obj3.print(); // 输出 "Template specialized for char and float"
}

template<typename T>
class Foo
{
public:
	void Bar();
};

template<>
void Foo<int>::Bar()
{
	cout << "Bar的int类型特例化" << endl;
}

int add(int a, int b) {
    int c = a + b;
    return c;
}
int main() {
    int x = add(1, 2);
}

// 回调函数
void Add(int a, int b) {
    cout << "加法结果: " << a + b << endl;
}

void Multiply(int a, int b) {
    cout << "乘法结果: " << a * b << endl;
}

// 执行回调的函数
void PerformOperation(int x, int y, void (*operation)(int, int)) {
    operation(x, y);  // 使用传入的函数指针
}

int main() {
    PerformOperation(5, 3, Add);       // 输出：加法结果: 8
    PerformOperation(5, 3, Multiply);  // 输出：乘法结果: 15
    return 0;
}

// 具体操作函数
int Add(int a, int b) { return a + b; }
int Subtract(int a, int b) { return a - b; }

// 返回函数指针的函数
int (*SelectOperation(char op))(int, int) {
    if (op == '+') return Add;
    if (op == '-') return Subtract;
    return nullptr;
}

int main() {
    char op;
    cout << "选择操作 (+ 或 -): ";
    cin >> op;
    // 获取并调用选中的函数
    auto func = SelectOperation(op);
    if (func) {
        cout << "结果: " << func(10, 5) << endl;
    }
    return 0;
}

class Base
{
public:
	virtual inline void foo()
	{
		cout << "Base foo" << endl;
	}
};
class Derived : public Base
{
public:
	inline void foo() override
	{
		cout << "Derived foo" << endl;
	}
};
int main()
{
	Base* bPtr = new Derived();
	bPtr->foo(); // 通过指针调用虚函数（不会内联展开）

	Derived dObj;
	dObj.foo(); // 通过对象调用虚函数（可能内联展开）
	//是当用对象调用虚函数（此时不具有多态性）时，就内联展开
	delete bPtr;
	return 0;
}

class A
{
public:
    virtual void foo()
    {
        cout<<"A::foo() is called"<<endl;
    }
};
class B:public A
{
public:
    void foo()
    {
        cout<<"B::foo() is called"<<endl;
    }
};
int main(void)
{
    A *a = new B();
    a->foo();   // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!
    return 0;
}

virtual void funtion1()=0

class Base { public: int data; };
class Derived1 : public Base {};
class Derived2 : public Base {};
class Final : public Derived1, public Derived2 {}; // 菱形继承

class Base { public: int data; };
class Derived1 : virtual public Base {}; // 虚继承
class Derived2 : virtual public Base {}; // 虚继承
class Final : public Derived1, public Derived2 {};

class Base { int data; };                      // sizeof(Base) = 4
class Derived1 : virtual public Base {};       // sizeof(Derived1) = 8 (vbptr) + 4 (Base) = 16（对齐）
class Final : public Derived1 {};              // sizeof(Final) = 16（无新增开销）

template<typename T>
class Shape
{
public:
	void draw()
	{
		static_cast<T*>(this)->draw();
	}
};

class Circle :public Shape<Circle>
{
public:
	void draw()
	{
		std::cout << "画圆\n";
	}
};

template <typename T>
class GameObject {
public:
    void update() {
        static_cast<T*>(this)->update_impl();
    }
};
 
class Player : public GameObject<Player> {
public:
    void update_impl() {
        // Implementation of player update logic
    }
};
 
class Enemy : public GameObject<Enemy> {
public:
    void update_impl() {
        // Implementation of enemy update logic
    }
};

template <typename T>
class Base
{
public:
	void interface(this T& self)
	{
		self.impl();
	}
};

class Derived :public Base<Derived>
{
public:
	void impl()
	{
		std::cout << "Derived class specific implementation\n";
	}
};

#include<memory>

class MyClass
{
public:
	MyClass(const std::string& name) : name(name)
	{
		std::cout << "MyClass " << name << " constructed.\n";
	}
	~MyClass()
	{
		std::cout << "MyClass " << name << " destroyed.\n";
	}
	void sayHello() const
	{
		std::cout << "Hello from " << name << "!\n";
	}
private:
	std::string name;
};

int main()
{
	std::shared_ptr<MyClass> shared1 = std::make_shared<MyClass>("Shared1"); // MyClass Shared1 constructed.
	{
		std::shared_ptr<MyClass> shared2 = shared1; // 共享所有权
		shared2->sayHello(); // Hello from Shared1!
		std::cout << "Shared pointer use count: " << shared1.use_count() << "\n"; // Shared pointer use count: 2
	}
	std::cout << "Shared pointer use count after shared2 out of scope: " << shared1.use_count() << "\n"; // Shared pointer use count after shared2 out of scope: 1
	shared1->sayHello(); // Hello from Shared1!
	// MyClass Shared1 destroyed.
	return 0;
}

// 上面的类
	std::unique_ptr<MyClass> unique = std::make_unique<MyClass>("unique"); // MyClass unique constructed.
	unique->sayHello(); // Hello from unique!
	// unique_ptr不允许拷贝，但是可以转移所有权
	std::unique_ptr<MyClass> unique2 = std::move(unique);
	if (!unique)
	{
		std::cout << "unique pointer has been moved.\n"; // unique pointer has been moved.
	}
	unique2->sayHello();// Hello from unique!
	// MyClass unique destroyed.

struct Node {
    std::shared_ptr<Node> child; // 父节点持有对子节点的 `shared_ptr`。
    std::shared_ptr<Node> parent; // 子节点持有对父节点的 `shared_ptr`。
};

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> child; // 子节点，shared_ptr
    std::weak_ptr<Node> parent;  // 父节点，使用 weak_ptr 避免循环引用

    Node() {
        std::cout << "Node created\n";
    }

    ~Node() {
        std::cout << "Node destroyed\n";
    }
};

int main() {
    // 创建父节点和子节点
    std::shared_ptr<Node> parent = std::make_shared<Node>();
    std::shared_ptr<Node> child = std::make_shared<Node>();

    // 创建父子关系
    parent->child = child; // 父节点持有子节点的 shared_ptr
    child->parent = parent; // 子节点持有父节点的 weak_ptr

    // 这里，parent 和 child 会正确销毁，因为 weak_ptr 不增加引用计数
    return 0;
}

#include<iostream>
using namespace std;

template<typename T>
class UniquePtr {
private:
	T* ptr;
public:
	explicit UniquePtr(T* p) :ptr(p) {}
	UniquePtr(const UniquePtr&) = delete;
	UniquePtr& operator=(const UniquePtr&) = delete;
	UniquePtr(UniquePtr&& other)noexcept :ptr(other.ptr) {
		other.ptr = nullptr;
	}
	UniquePtr& operator=(UniquePtr&& other)noexcept {
		if (this != other) {
			delete ptr;
			ptr = other.ptr;
			other.ptr = nullptr;
		}
		return *this;
	}
	T& operator*()const {
		return *ptr;
	}
	T* operator->()const {
		return ptr;
	}
	T* release() {
		T* tmp = ptr;
		ptr = nullptr;
		return tmp;
	}
	void reset(T* p = nullptr) {
		delete ptr;
		ptr = p;
	}
	~UniquePtr() {
		delete ptr;
	}
};

class MyClass
{
public:
	void show() {
		cout << "调用MyClass类的show函数" << endl;
	}
	MyClass() {
		cout << "构造函数" << endl;
	}
	~MyClass() {
		cout << "析构函数" << endl;
	}
};

int main() {
	UniquePtr<MyClass> ptr1(new MyClass());
	UniquePtr<int> ptr2(new int(2));
	ptr1->show();
	cout << ptr2.release() << endl;
	return 0;
}

#include<iostream>
using namespace std;

template<typename T>
class SharedPtr {
private:
	T* ptr;
	int* ref_count;
public:
	explicit SharedPtr(T* p = nullptr) :ptr(p), ref_count(new int(p ? 1 : 0)){}
	SharedPtr(const SharedPtr& other) noexcept : ptr(other.ptr), ref_count(other.ref_count) {
	if (ptr) (*ref_count)++;
	}
	SharedPtr(SharedPtr&& other)noexcept :ptr(other.ptr), ref_count(other.ref_count) {
		other.ptr = nullptr;
		other.ref_count = nullptr;
	}
	SharedPtr& operator=(const SharedPtr& other)noexcept {
		if (this != &other) {
			release();
			ptr = other.ptr;
			ref_count = other.ref_count;
			if (ptr) (*ref_count)++;
		}
		return *this;
	}
	SharedPtr& operator=(SharedPtr&& other)noexcept {
		if (this != &other) {
			release();
			ptr = other.ptr;
			ref_count = other.ref_count;
			other.ptr = nullptr;
			other.ref_count = nullptr;
		}
		return *this;
	}
	int use_count() const {
		return ptr ? *ref_count : 0;
	}
	~SharedPtr() {
		release();
	}
	T* operator->()const {
		return ptr;
	}
	T& operator*()const {
		return *ptr;
	}
private:
	void release() {
		if (ref_count && --(*ref_count) == 0) {
			delete ptr;
			delete ref_count;
		}
		ptr = nullptr;
		ref_count = nullptr;
	}
};

class MyClass
{
public:
	MyClass() {
		cout << "构造函数\n";
	}
	~MyClass() {
		cout << "析构函数\n";
	}
	void show() {
		cout << "调用MyClass中的show方法" << endl;
	}
};

int main() {
	SharedPtr<MyClass> ptr1(new MyClass());
	SharedPtr<MyClass> ptr2 = ptr1;
	ptr2->show();
	cout << ptr2.use_count() << endl;
	return 0;
}

auto f1 = [](int a, int b)->int {return a + b; };
std::cout << f1(1, 2) << std::endl;

	int N = 100, M = 10;
	auto g = [N, &M, k = 5](int i)
	{
		M = 20; // &M：按引用捕获，Lambda 表达式对 M 的修改会直接反映到外部变量 M 上。
		std::cout << k << std::endl; // 5
		return N * i;
	};
	std::cout << g(10) << std::endl;
	std::cout << M << std::endl;

int a = 10;  // a 是左值
int* p = &a; // 可以对左值取地址

int b = a + 5; // (a + 5) 是右值，结果是一个临时值
int* p = &(a + 5); // 错误，不能对右值取地址

std::string createString() {
    return "Hello"; // 返回一个临时的 std::string 对象（将亡值）
}

std::string&& rvalueRef = createString(); // 捕获将亡值

void PrintName(const std::string& name) {
    std::cout << "[lvalue] " << name << std::endl;
}
void PrintName(const std::string&& name) {
    std::cout << "[rvalue] " << name << std::endl;
}
 
std::string firstName = "Yan";
std::string lastName = "Chernikov";
std::string fullName = firstName + lastName;
 
PrintName(fullName); // [lvalue] YanChernikov
PrintName(firstName + lastName); // [rvalue] YanChernikov

void f(const string& s)
{
	cout << "左值" << s << endl;
}
void f(const string&& s)
{
	cout << "右值" << s << endl;
}
void g(const string& s)
{
	f(static_cast<const string&>(s));
}
void g(const string&& s)
{
	f(static_cast<const string&&>(s));
}
int main()
{
	g(string("Hello1")); // 右值Hello1
	string s1("Hello2");
	g(s1); // 左值Hello2
	return 0;
}

template<class T>
// 万能引用 既可以绑定右值又可以绑定左值
void g(T&& v)
{
	f(std::forward<T>(v));
}

void sayhello(int a, int b)
{
	cout << "hello" << a << b << endl;
}
void sayhello2(int& a, int& b)
{
	a += 5, b += 10;
	cout << a << "," << b;
}
int main()
{
	// 创建子线程
	// 传递一个可调对象
	thread t1(sayhello, 10, 20);
	t1.join();// 阻塞主线程
	// main所在线程就是主线程
	cout << "this is main" << endl;

    int x = 10, y = 20;
	thread t2(sayhello2, ref(x), ref(y));//引用传递
	return 0;
}

	MyClass obj;
	// 传递成员函数指针和成员函数对象
	thread t(&MyClass::memberFunctionTask, &obj);
	t.join();

thread t1([]() {cout << "hello lambda\n"; });
t1.join();

struct Functor
{
	void operator()()
	{
		cout << "Functor task executed\n";
	}
};
int main()
{
	Functor f;
	thread t(f);
	t.join();
	return 0;
}

auto boundFunc = bind(functionWithArgs, 1, 2);
thread t(boundFunc);
t.join();

#include<iostream>
#include<thread>
#include<mutex>
using namespace std;
// 共享变量 没有使用互斥锁/原子操作
int counter = 0;
mutex myMutex; //声明互斥锁
// 线程函数 对counter进行递增操作
void increment_counter(int times)
{
	for (int i = 0; i < times; i++)
	{
		myMutex.lock(); // 加锁
		counter++;
		myMutex.unlock(); // 解锁
	}
}
int main()
{
	thread t1(increment_counter, 100000);
	thread t2(increment_counter, 100000);
	t1.join();
	t2.join();
	cout << "最终的结果" << counter << endl;
	return 0;
}

void sum()
{
	lock_guard<mutex> lock(mymutex); // 保护的是mutex类型的锁mymutex
	for (size_t i = 0; i < 10000; i++)
	{
		mycount++;
	}// 超出生命周期自动解锁
}

mutex mtx;
condition_variable cv;
bool flag = false;
void myprint(int i)
{
	unique_lock<mutex> lck(mtx);
	while (!flag)
	{
		cv.wait(lck); // 条件不成立 进入阻塞状态 释放掉锁 等待别人唤醒
	}
	cout << this_thread::get_id() << "-" << i << endl;
}
void updateflag()
{
	cout << "this is update" << endl;
	this_thread::sleep_for(3s);
	unique_lock<mutex> lck(mtx);
	flag = true;
	cv.notify_all(); // 通知所有的线程
	// cv.notify_one(); // 通知一个
}
int main()
{
	vector<thread> mybox;
	for (size_t i = 0; i < 10; i++)
		mybox.emplace_back(myprint, i);
	updateflag();
	for (thread& t : mybox)
		t.join();
	return 0;
}

mutex mtx;
condition_variable cv;
int myvalue = 0;
bool turn = false;
void increment(int id)
{
	for (int i = 0; i < 10; i++)
	{
		unique_lock<mutex> lock(mtx);
		cv.wait(lock, [&] {return (id == 1) ? !turn : turn; });
		++myvalue;
		cout << "thread " << id << " " << myvalue << endl;
		turn = !turn;
		cv.notify_all();
	}
}
int main()
{
	thread t1(increment, 1);
	thread t2(increment, 2);
	t1.join();
	t2.join();
	cout << myvalue << endl; // t1 t2交替执行 thread 1 1 thread 2 2 thread 1 3 thread 2 4...
	return 0;
}

shared_mutex rw_mutex;
int shared_data = 0;
void reader()
{
	shared_lock<shared_mutex> lock(rw_mutex);
	cout << "reader thread " << this_thread::get_id() << "value " << shared_data << endl;
}
void writer(int value)
{
	unique_lock<shared_mutex> lock(rw_mutex);
	shared_data = value;
	cout << "writer thread " << this_thread::get_id() << "value " << shared_data << endl;
}
int main()
{
	vector<thread> threads;
	for (int i = 0; i < 5; i++)
	{
		threads.emplace_back(reader);
	}
	for (int i = 0; i < 5; i++)
	{
		threads.emplace_back(writer, i);
	}
	for (auto& t : threads)
	{
		t.join();
	}
	return 0;
}