#include<iostream>
using namespace std;

int main() {
	cout << "Hello world" << endl;
	system("pause");
	return 0;
}

if (condition) {
    /* code */
} 
else if (condition) {
    /* code */
}
// ...
else {
    /* code */
}

表达式1 ? 表达式2:表达式3

switch (expression) {
    case constant expression:
        /* code */
        break;
	// ...
    default:
        break;
}
// expression为整型或者字符型
// case没有break，则会一直向下执行

while (condition) {
    /* code */
}

do
{
    /* code */
} while (condition);

for (size_t i = 0; i < count; i++) {
    /* code */
}

返回值类型 函数名(参数类型 形参列表) {
    函数体语句;
    return 表达式;
}

// ASCII 文件
#include <fstream>
using namespace std;

int main() {
	ofstream ofs;
	ofs.open("test.txt", ios::out);
	ofs << "姓名：张三" << endl;
	ofs << "性别：男" << endl;
	ofs << "年龄：18" << endl;
	ofs.close();

    ifstream ifs;
	ifs.open("test.txt", ios::in);
    if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
		return;
	}
    char buf[1024] = { 0 };
	while (ifs >> buf) {
		cout << buf << endl;
	}
    ifs.close();
    
	return 0;
}

// binary 文件
#include <fstream>
using namespace std;

int main() {
	ofstream ofs;
	ofs.open("person.txt", ios::out | ios::binary);
	int p = 1;
	ofs.write((const char *)&p, sizeof(p));
	ofs.close();
	
	ifstream ifs;
    ifs.open("person.txt", ios::in | ios::binary);
	if (!ifs.is_open()) {
		cout << "文件打开失败" << endl;
	}
    int p;
	ifs.read((char *)&p, sizeof(p));
	ifs.close();

	return 0;
}

#pragma once
#include <iostream>
#include <cmath>
using namespace std;

class Point
{
    // friend ...
public:
	Point();		// 默认构造，即无参构造
	Point(double x, double y);		// 有参构造
    Point(const Point& point);		// 拷贝构造
	~Point() = default;		
	double getX();
	double getY();
	void setX(double x);
	void setY(double y);
    
    static void setFlag(int target);
    void constfix() const;
    void nullCheck();
public:
    mutable int index;
    static int flag;
private:
	double x;
	double y;
};

class Circle
{
public:
	Circle() = default;
    // 默认构造，对应成员属性的默认初始化
	Circle(double radius, Point center);
	~Circle() = default;
	double getRadius();
	Point getCenter();
	void setRadius(double radius);
	void setCenter(Point center);
private:
	double radius;
	Point center;
};

#include "circle.h"

Point::Point(): x(0), y(0) {}
Point::Point(double a, double b): x(a), y(b) {}
Point::Point(const Point& point) {
    this->x = point.x;
    this->y = point.y;
}
double Point::getX() {
    return x;
}
double Point::getY() {
    return y;
}
void Point::setX(double x) {
    this->x = x;
}
void Point::setY(double y) {
    this->y = y;
}
void Point::setFlag(int target) {
    flag = target;
}
int Point::flag = 0;
void Point::constfix() const {
    this->index = 1;
    cout<< this->index << endl;
}

void Point::nullCheck() {
    if(this == NULL) return;
    cout<< this->x << ',' << this->y << endl;
}

Circle::Circle(double radius, Point center) {
    this->radius = radius;
    this->center = center;
}
double Circle::getRadius() {
    return radius;
}
Point Circle::getCenter() {
    return center;
}
void Circle::setRadius(double radius) {
    this->radius = radius;
}
void Circle::setCenter(Point center) {
    this->center = center;
}

// 无参构造
Point p1;  
Point p2{};  // Point p11 = {};

// 有参构造
Point p3(10, 20);
Point p4{5, 15};  // Point p10 = {5, 15};
// 拷贝构造
Point p6(p3);         // 显示拷贝构造
Point p5 = p3;        // 隐式拷贝构造
Point p7 = Point(p3); // 匿名对象拷贝构造
// 拷贝赋值运算符
Point p8;
p8 = p3;
// 移动赋值运算符
Point p9;
p9 = Point(p3);
p9 = std::move(p2);
// 不允许单独构造匿名对象
// Point(p4);
// 这是一个函数声明
 // Point p1();

p1.flag = 1;  				// Point::flag
p1.setFlag(1);				// Point::setFlag(1);

Point *p = NULL;
p->nullCheck();

const Point pa;
pa.constfix();

┌─────────────────────────────┐
│       代码区 (Text)          │
│  - 所有可执行代码		     │
│  - 成员函数代码（共享）		   │
│  - 虚函数表（vtable）	      │
├─────────────────────────────┤
│       数据区 (Data)          │
│  - 全局变量        		   │
│  - 静态成员变量（共享）		   │
│  - 字符串常量		   		  │
├─────────────────────────────┤
│       BSS区 (未初始化数据)    │ 
│  - 未初始化数据	    	      │
├─────────────────────────────┤
│       堆 (Heap)             │ ← new创建的对象
│  ┌─────────────────────┐    │
│  │ 对象1: 			    │    │
│  │  - 虚函数表指针(vptr) │    │
│  │  - int, char...     │    │
│  └─────────────────────┘    │
│  ┌─────────────────────┐    │
│  │ 对象2: ... 		    │    │
│  └─────────────────────┘    │
├─────────────────────────────┤
│           栈 (Stack)        │ ← 局部对象
│  ┌─────────────────────┐    │
│  │ 对象3: 			    │    │
│  │  - 虚函数表指针(vptr) │    │
│  │  - int, char...     │    │
│  └─────────────────────┘    │
└─────────────────────────────┘

class Person
{
public:
	Person() = default;
	Person(string name) {
		this->name = name;
        this->total = 1;
	};
	~Person() = default;

public:
	string name;
    int total;

public:
    // 成员函数实现 + 重载
    // p_object + p_param 或者 p_object.operator+(p_param)
    Person operator+(const Person& p) {
        Person temp("sum");
        temp.total = this->total + p.total;
        return temp;
    }

    // 成员函数实现 << 重载
    // p_object << cout 或者 p_object.operator<<(cout) 左附加
     ostream& operator<<(ostream& os) {
        os << this->name << " " << this->total << endl;
        return os;
    }

    // 成员函数实现 前置++ 重载
    // ++p_object 或者 p_object.operator++()
    Person& operator++() {
        this->total++;
        return *this;
    }

    // 成员函数实现 后置++ 重载
    // p_object++ 或者 p_object.operator++(0)
    Person operator++(int) {
        Person temp = *this;
        this->total++;
        return temp;
    }

    // 成员函数实现 = 重载
    // p_object = p_param 或者 p_object.operator=(p_param) 右优先
    Person& operator=(const Person& p) {
        this->name = p.name;
        this->total = p.total;
        return *this;
    }

    // 成员函数实现 == 重载
    // p_object == p_param 或者 p_object.operator==(p_param)
    bool operator==(const Person& p) {
        return this->total == p.total;
    }

    // 成员函数实现 () 重载
    // p_object(string_param) 或者 p_object.operator()(string_param) 仿函数
    // 与匿名对象Person(string_param)有点像
    void operator()(string name) {
        this->name = name;
        return;
    }
}; 

//全局函数实现 + 重载
//p1 + p2 或者 operator+(p1, p2)
Person operator+(const Person& p1, const Person& p2) {
    Person temp("sum");
    temp.total = p1.total + p2.total;
    return temp;
}

//全局函数实现 << 重载
//cout << p 或者 operator<<(cout, p) 右附加
ostream& operator<<(ostream& os, const Person& p) {
    os << p.name << " " << p.total << endl;
    return os;
}

class Animal
{
public:
    Animal() = default;
    Animal(string name) : name(name) {}
    virtual ~Animal() = default;

    virtual void makeSound() const
    {
        cout << name << " makes a sound." << endl;
    };

    string getName() const
    {
        return name;
    }
    string name;
};

class Dog : virtual public Animal
{
public:
    Dog(string name) : Animal(name) {}
    ~Dog() = default;

    void makeSound() const override
    {
        cout << name << " says: Woof!" << endl;
    }

    int DogId;
};

class Cat : virtual public Animal
{
public:
    Cat(string name) : Animal(name) {}
    ~Cat() = default;

    void makeSound() const override
    {
        cout << name << " says: Meow!" << endl;
    }

    int CatId;
};

class DogCat : public Dog, public Cat
{
public:
    DogCat(string name) : Animal(name), Dog(name), Cat(name) {}
    ~DogCat() = default;

    void makeSound() const override
    {
        Dog::makeSound();
        Cat::makeSound();
    }
};

DogCat 菱形继承对象：
+-----------------------+  ← 0x00 (Dog部分开始)
| Dog::Animal::vptr (8) | → Dog::Animal 虚函数表（指向DogCat覆盖后的版本）
+-----------------------+  ← 0x08
| Dog::Animal::name (32)| → Animal::name (Dog版本)
+-----------------------+  ← 0x28
| Dog::Animal::DogId (4)|
| 对齐填充 (4)           |
+-----------------------+  ← 0x30 (Cat部分开始)
| Cat::Animal::vptr (8) | → Cat::Animal 虚函数表（指向DogCat覆盖后的版本）
+-----------------------+  ← 0x38
| Cat::Animal::name (32)| → Animal::name (Cat版本)
+-----------------------+  ← 0x58
| Cat::Animal::CatId (4)|
| 对齐填充 (4)           |
+-----------------------+  ← 0x60 (DogCat自身成员开始)
| DogCat成员（暂无）      |
+-----------------------+
总大小：~96字节+（两个完整的Animal副本）

DogCat 虚继承对象：
+-----------------+  ← 0x00 (Dog部分开始)
| Dog::vptr (8)   | → Dog虚函数表（指向DogCat覆盖后的版本,包含虚基类偏移信息）
+-----------------+  ← 0x08
| Dog::DogId (4)  |
| 对齐填充 (4)     |
+-----------------+  ← 0x10 (Cat部分开始)
| Cat::vptr (8)   | → Cat虚函数表（指向DogCat覆盖后的版本,包含虚基类偏移信息）
+-----------------+  ← 0x18
| Cat::CatId (4)  |
| 对齐填充 (4)     |
+-----------------+  ← 0x20 (DogCat自身成员开始)
| DogCat成员（暂无）|
+-----------------+  ← 0x28 (Animal虚基类部分开始)
| Animal::vptr (8)| → Animal虚函数表（指向DogCat覆盖后的版本）
+-----------------+  ← 0x30
| Animal::name(32)| → 唯一的name对象
+-----------------+
总大小：~72字节+

void speak(Animal* a) {
    a->makeSound();
    delete a; 
}
speak(new Cat("Fluffy"));
speak(new Dog("Rover"));

Dog对象内存布局（独立时）：
+----------------+
| Dog::vptr (8)  | → Dog虚函数表
+----------------+
| DogId (4)      |
| padding (4)    | → 对齐到8字节边界
+----------------+
| Animal部分     | → 虚基类
| - Animal::vptr |
| - name         |
+----------------+

Cat对象内存布局（独立时）：
+----------------+
| Cat::vptr (8)  | → Cat虚函数表
+----------------+
| CatId (4)      |
| padding (4)    |
+----------------+
| Animal部分     | → 虚基类
| - Animal::vptr |
| - name         |
+----------------+

Dog vtable for Dog (独立对象)：
+---------------------+
| typeinfo for Dog    |  ← RTTI信息
+---------------------+
| offset to top: 0    |  ← 到Dog对象顶部的偏移（总是0）
+---------------------+
| vbase offset: 16    |  ← Dog子对象到Animal部分的偏移
                       // 计算公式：Animal地址(0x10) - Dog地址(0x00) = 0x10(16)
+---------------------+
| Dog::~Dog()         |  ← 析构函数（Dog版本）
+---------------------+
| Dog::makeSound()    |  ← Dog自己的makeSound实现
+---------------------+

Animal vtable for Dog (独立对象)：
+---------------------+
| typeinfo for Dog    |  ← RTTI信息
+---------------------+
| Dog::~Dog()         |  ← 析构函数（最终覆盖）
+---------------------+
| Dog::makeSound()    |  ← Dog覆盖的makeSound
+---------------------+

Cat vtable for Cat (独立对象)：
+---------------------+
| typeinfo for Cat    |  ← RTTI信息
+---------------------+
| offset to top: 0    |  ← 到Cat对象顶部的偏移（总是0）
+---------------------+
| vbase offset: 16    |  ← Cat子对象到Animal部分的偏移
                       // 计算公式：Animal地址(0x10) - Cat地址(0x00) = 0x10(16)
+---------------------+
| Cat::~Cat()         |  ← 析构函数（Cat版本）
+---------------------+
| Cat::makeSound()    |  ← Cat自己的makeSound实现
+---------------------+

Animal vtable for Cat (独立对象)：
+---------------------+
| typeinfo for Cat    |  ← RTTI信息
+---------------------+
| Cat::~Cat()         |  ← 析构函数（最终覆盖）
+---------------------+
| Cat::makeSound()    |  ← Cat覆盖的makeSound
+---------------------+

bool myCompare(int a, int b)
{
    cout << "普通函数被调用" << endl;
    return a != b;
}

template <typename T>
bool myCompare(T a, T b)
{
    cout << "泛化模板函数被调用" << endl;
    return a != b;
}

template <>
bool myCompare<int *>(int *a, int *b) {
    cout << "特化模板函数被调用" << endl;
    return *a != *b;
}

template bool myCompare<int>(int a, int b); // 声明显式实例化

// 隐式实例化
myCompare(1, 1); // 自动推导，int, 不可隐式转换
myCompare<int>(1, 1); // 显式指定, int，可隐式转换
// myCompare(3, 3.14)  error, 类型不一致或不确定
myCompare<>(1, 1);    // 强制模板, int

// 类外实现成员函数
template<typename T1, typename T2>
class Person {
public:
	Person(T1 name, T2 age);
public:
	T1 m_Name;
	T2 m_Age;
};

template<typename T1, typename T2>
Person<T1, T2>::Person(T1 name, T2 age) {
	this->m_Name = name;
	this->m_Age = age;
}

// 含默认参数
template<typename NameType, typename AgeType = int> 
class Person {
public:
    Person(NameType name, AgeType age) 
        : mName(name), mAge(age) {}
private:
    NameType mName;
    AgeType mAge;
};

// 部分特化的类模板成员不需要和泛化模板成员保持完全一致
template <typename NameType>
class Person<NameType, int> {
public:
    Person(NameType name, int age)
		: mName(name), mAge(age) {}
    void func() {
        cout << "这是模板的部分特化版本" << endl;
    }
private:
    NameType mName;
    int mAge;
};

// 只允许显式指定，不存在自动推导
Person<string> p1("孙悟空", 999); 
Person<string, double> p2("唐僧", 30.5);

// 非类型参数类模板，是编译期常量
template <typename NameType, int N>
class Person {
public:
    Person(NameType name, int age) 
        : mName(name), mAge(age) {}
private:
    NameType mName;
    int mAge;
    int mDefaultAge = N;
};

Person<string, 100> p("默认年龄100", 50);

// 嵌套模板
template <typename T， template<typename> class Container>
class Wrapper {
public:
    Wrapper(const Container<T> &d) : data(d) {}
    void display() {
        for (const auto &item : data)
            cout << item << " ";
        cout << endl;
    }
private:
    Container<T> data;
};

vector<int> v = {1, 2, 3, 4, 5};
Wrapper<vector, int> example(v);
example.display();

// 模板参数传递
void printPerson1(Person<string> &p);  // 指定传入的类型

template <typename T>
void printPerson2(Person<T> &p);   // 模板参数模板化

template<typename T>
void printPerson3(T & p);			// 模板整体模板化

// 模板继承
class Son :public Base<int>
    
template<typename T>
class Son :public Base<T>		// 灵活指定

// 模板友元
// 友元全局函数类内实现
template<typename T1, typename T2>
class Person
{
	friend void printPerson(Person<T1, T2> & p) {
		cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
	}
    // ...
};
printPerson(p);

// 友元全局函数类外实现
template<typename T1, typename T2> class Person;
template<typename T1, typename T2>
void printPerson(Person<T1, T2> & p);

template<typename T1, typename T2>
class Person
{
	friend void printPerson<>(Person<T1, T2> & p);
    // ...
};

template<typename T1, typename T2>
void printPerson(Person<T1, T2> & p)
{
	cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}

printPerson(p);

#pragma once
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
public:
	MyArray() = default;
	MyArray(int capacity) {
		this->m_Size = 0;
		this->m_Capacity = capacity;
		pAddress = new T[this->m_Capacity];
	}
	MyArray(const MyArray & arr) {
		this->m_Size = arr.m_Size;
		this->m_Capacity = arr.m_Capacity;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < this->m_Size; i++) {
			this->pAddress[i] = arr.pAddress[i];
		}
	}
    ~MyArray() {
		if (this->pAddress != NULL) {
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}
	}

	MyArray& operator=(const MyArray& myarray) {
		if (this->pAddress != NULL) {
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}
		this->m_Size = myarray.m_Size;
		this->m_Capacity = myarray.m_Capacity;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < this->m_Size; i++) {
			this->pAddress[i] = myarray[i];
		}
		return *this;
	}

	T& operator[](int index) {
		return this->pAddress[index]; //不考虑越界，用户自己去处理
	}

	void Push_back(const T & val) {
		if (this->m_Capacity == this->m_Size) {
			return;
		}
		this->pAddress[this->m_Size] = val;
		this->m_Size++;
	}

	void Pop_back() {
		if (this->m_Size == 0) {
			return;
		}
		this->m_Size--;
	}

	int getCapacity() {
		return this->m_Capacity;
	}

	int	getSize() {
		return this->m_Size;
	}

private:
	T * pAddress;  
	int m_Capacity;
	int m_Size;
};

class MyAdd
{
public :
    MyAdd() {
        this->count=0;
    }
	int operator()(int v1,int v2) {
        this->count++;
		return v1 + v2;
	}
    int count;
};
MyAdd myAdd;
myAdd(10, 10);
// myAdd.count