#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(0, 0);  				// 括号有参构造
Point p3 = Point(p2); 			// 显示有参构造，匿名对象
Point p4 = p3;					// 隐式有参构造
// 不能拷贝构造匿名对象
// Point(p4);

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

CatDog 菱形继承对象：
┌─────────────────┐
│ Cat 部分         │
│   ├ Animal数据   │ ← name (副本1)
│   └ CatId   	  │
├─────────────────┤
│ Dog 部分         │
│   ├ Animal数据   │ ← name (副本2)
│   └ DogId   	  │
├─────────────────┤
│ CatDog 部分	     │
└─────────────────┘
CatDog 虚继承对象（父类数据不在虚继承子类中）：
┌─────────────────┐
│ Cat 部分         │
| 虚基类指针(Cat)   | ← 指向 Animal部分
│   └ CatId   	  │
├─────────────────┤
│ Dog 部分         │
| 虚基类指针(Dog)   | ← 指向 Animal部分
│   └ DogId   	  │
├─────────────────┤
│ CatDog部分       │
├─────────────────┤
│ Animal部分       │ ← 只有一个共享副本！
│  └ name          │
└─────────────────┘

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

+-------------------+
| vfptr (vtable)      |  <- 指向该对象所属类的虚函数表！
+-------------------+
| 成员变量            |
+-------------------+

#include <iostream>
using namespace std;

// 主模板声明
template <typename T>
bool myCompare(T a, T b);

// 精确匹配的普通函数
bool myCompare(int a, int 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);

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

int main()
{
    int x = 1, y = 2;
    myCompare(x, y);      // 自动推导，调用普通函数
    myCompare<>(x, y);    // 自动推导，强制调用模板函数
    myCompare(&x, &y);    // 显示指定，调用特化模板函数
    myCompare<int>(x, y); // 显示指定，调用泛化模板函数
}

// 含默认类模板
template<typename NameType, typename AgeType = int> 
class Person
{
public:
	Person(NameType name, AgeType age) {
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() {
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

// 部分特化类模板
template <typename NameType>
class Person<NameType, int>
{
public:
    Person(NameType name, int age)
    {
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
        cout << "姓名: " << this->mName << " 年龄: " << this->mAge << endl;
    }
    void func()
    {
        cout << "这是模板的全特化版本" << endl;
    }

public:
    NameType mName;
    int mAge;
};

Person<string> P1("孙悟空", 999);		// 没有自动类型推导
P1.showPerson();

template<typename T1, typename T2>
class Person {
public:
	Person(T1 name, T2 age);
	void showPerson();
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 T1, typename T2>
void Person<T1, T2>::showPerson() {
	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

// 非类型参数类模板 常量、引用、指针
template <typename NameType, int N>
class Person
{
public:
    Person(NameType name, int age)
    {
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
        cout << "name: " << this->mName << " age: " << this->mAge << endl;
    }

public:
    NameType mName;
    int mAge = N;
};

// 嵌套模板
template <template <typename> typename Container, typename T>
class Wrapper
{
private:
    Container<T> data;

public:
    Wrapper(const Container<T> &d) : data(d) {}
    void display()
    {
        for (const auto &item : data)
        {
            cout << item << " ";
        }
        cout << endl;
    }
};

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

void printPerson1(Person<string> &p);

template <typename T1>
void printPerson2(Person<T1> &p);

template<typename T>
void printPerson3(T & p);

class Son :public Base<int>

template<typename T1, typename T2>
class Son :public Base<T2>

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