#include <iostream>
using namespace std;

//圆周率
const double PI = 3.14;

//1、封装的意义
//将属性和行为作为一个整体，用来表现生活中的事物

//封装一个圆类，求圆的周长
//class代表设计一个类，后面跟着的是类名
class Circle
{
public:  //访问权限  公共的权限

	//属性
	int m_r;//半径

	//行为
	//获取到圆的周长
	double calculateZC()
	{
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

int main() {

	// 通过圆类，创建圆的对象
	// c1就是一个具体的圆
	Circle c1;
	c1.m_r = 10; //给圆对象的半径 进行赋值操作

	//2 * pi * 10 = = 62.8
	cout << "圆的周长为： " << c1.calculateZC() << endl;

	system("pause");
	return 0;
}

#include <iostream>
using namespace std;

//学生类
class Student {
public:
	void setName(string name) {
		m_name = name;
	}
	void setID(int id) {
		m_id = id;
	}

	void showStudent() {
		cout << "name:" << m_name << " ID:" << m_id << endl;
	}
public:
	string m_name;
	int m_id;
};

int main() {

	Student stu;
	stu.setName("小w");
	stu.setID(100);
	stu.showStudent();

	system("pause");
	return 0;
}

#include <iostream>
using namespace std;

//三种权限
//公共权限  public     类内可以访问  类外可以访问
//保护权限  protected  类内可以访问  类外不可以访问
//私有权限  private    类内可以访问  类外不可以访问

class Person
{
	//姓名  公共权限
public:
	string m_Name;

	//汽车  保护权限
protected:
	string m_Car;

	//银行卡密码  私有权限
private:
	int m_Password;

public:
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}
};

int main() {

	Person p;
	p.m_Name = "李四";
	//p.m_Car = "奔驰";  //保护权限类外访问不到
	//p.m_Password = 123; //私有权限类外访问不到

	system("pause");
	return 0;
}

#include <iostream>
using namespace std;

class C1
{
	int  m_A; //默认是私有权限
};

struct C2
{
	int m_A;  //默认是公共权限
};

int main() {

	C1 c1;
	c1.m_A = 10; //错误，访问权限是私有

	C2 c2;
	c2.m_A = 10; //正确，访问权限是公共

	system("pause");
	return 0;
}

#include <iostream>
using namespace std;

class Person {
public:

	//姓名设置可读可写
	void setName(string name) {
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}

	//获取年龄 
	int getAge() {
		return m_Age;
	}
	//设置年龄
	void setAge(int age) {
		if (age < 0 || age > 150) {
			cout << "你个老妖精!" << endl;
			return;
		}
		m_Age = age;
	}

	//偶像设置为只写
	void setIdol(string idol) {
		m_Idol = idol;
	}

private:
	string m_Name; //可读可写  姓名
	
	int m_Age; //只读  年龄

	string m_Idol; //只写  偶像
};


int main() {

	Person p;
	//姓名设置
	p.setName("张三");
	cout << "姓名： " << p.getName() << endl;

	//年龄设置
	p.setAge(50);
	cout << "年龄： " << p.getAge() << endl;

	//偶像设置
	p.setIdol("小明");
	//cout << "偶像： " << p.m_Idol << endl;  //只写属性，不可以读取

	system("pause");
	return 0;
}

#include <iostream>
using namespace std;

class Cube {
public:
    // 行为
    // 设置长
    void setL(int L) {
        m_L = L;
    }

    // 获取长
    int getL() {
        return m_L;
    }
    // 设置宽
    void setW(int W) {
        m_W = W;
    }

    // 获取宽
    int getW() {
        return m_W;
    }

    // 设置高
    void setH(int H) {
        m_H = H;
    }
    // 获取高
    int getH() {
        return m_H;
    }

    // 获取长方体面积
    int getArea() {
        return 2 * (m_L * m_W + m_L * m_H + m_W * m_H);
    }

    // 获取长方体体积
    int getVolume() {
        return m_L * m_W * m_H;
    }

    // 利用成员函数判断两个长方体是否相等
    bool isEqualByClass(Cube& cube) {
        return m_L == cube.getL() && m_W == cube.getW() && m_H == cube.getH();
    }

private:
    // 属性
    int m_L;
    int m_W;
    int m_H;
    
};

// 利用全局函数判断两个长方体是否相等
bool isEqual(Cube& cube1, Cube& cube2) {
    return cube1.getL() == cube2.getL() && cube1.getW() == cube2.getW() && cube1.getH() == cube2.getH();
}

int main() {
    Cube cube;
    cube.setL(10);
    cube.setW(20);
    cube.setH(30);
    cout << "面积：" << cube.getArea() << endl;
    cout << "体积：" << cube.getVolume() << endl;

    Cube cube2;
    cube2.setL(10);
    cube2.setW(20);
    cube2.setH(30);
    cout << "第二个长方体的长宽高：" << cube2.getL() << " " << cube2.getW() << " " << cube2.getH() << endl;
    if (cube.isEqualByClass(cube2)) {
        cout << "利用成员函数判断，两个长方体相等" << endl;
    }
    else {
        cout << "利用成员函数判断，两个长方体不相等" << endl;
    }

    if (isEqual(cube, cube2)) {
        cout << "利用全局函数判断，两个长方体相等" << endl;
    }
    else {
        cout << "利用全局函数判断，两个长方体不相等" << endl;
    }

    return 0;
    
}

#include <iostream>
using namespace std;

class Person
{
public:
	// 构造函数
    // 构造函数没有返回值，也没有返回类型
	// 构造函数的函数名和类名相同
	// 构造函数可以有参数，也可以重载
	// 构造函数在创建对象时自动调用，而且只调用一次
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	// 析构函数
    // 析构函数没有返回值，也没有返回类型
	// 析构函数的函数名和类名相同，在名称前加上~
	// 析构函数不可以有参数，不可以重载
	// 析构函数在对象销毁时自动调用，而且只调用一次
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

// 构造和析构都是必须有的实现，如果没有，编译器会自动生成一个默认的构造和析构函数
void test01()
{
	Person p; // 在栈上的数据，出了作用域就自动销毁
}

int main() {
	
	test01();

	return 0;
}

#include <iostream>
using namespace std;

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
}

int main() {

	test01();
	//test02();
	
	return 0;
}

#include <iostream>
using namespace std;

class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person p1(20); //p对象已经创建完毕
	Person p2(p1); //调用拷贝构造函数
	
    cout << "p2的年龄为：" << p2.mAge << endl;

}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
	Person p; //无参构造函数
	doWork(p);
}

//3. 以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int *)&p1 << endl;
	return Person(p1);
}

void test03()
{
	Person p = doWork2();
	cout << (int *)&p << endl;
}


int main() {

	// test01();
	// test02();
	test03();

	return 0;
}

#include <iostream>
using namespace std;

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

void test01()
{
	Person p1(18);
	//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
	Person p2(p1);

	cout << "p2的年龄为： " << p2.age << endl;
}

void test02()
{
	//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
	Person p1; //此时如果用户自己没有提供默认构造，会出错
	Person p2(10); //用户提供的有参
	Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供

	//如果用户提供拷贝构造，编译器不会提供其他构造函数
	Person p4; //此时如果用户自己没有提供默认构造，会出错
	Person p5(10); //此时如果用户自己没有提供有参，会出错
	Person p6(p5); //用户自己提供拷贝构造
}

int main() {

	test01();

	return 0;
}

#include <iostream>
using namespace std;

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {
		
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
		
	}

	//析构函数
	~Person() {
        // 析构代码，将堆区开辟数据释放
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
            m_height = NULL;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);
	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {

	test01();

	return 0;
}

#include <iostream>
using namespace std;

class Person {
public:

	////传统方式初始化
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

int main() {

	Person p(1, 2, 3);
	p.PrintPerson();

	return 0;
}

class A {}
class B
{
    A a；
}

#include <iostream>
#include <string>
using namespace std;

class Phone
{
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}

	~Phone()
	{
		cout << "Phone析构" << endl;
	}

	string m_PhoneName;

};


class Person
{
public:

	//初始化列表可以告诉编译器调用哪一个构造函数
    // Phone m_Phone = pName 隐式转换法
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person构造" << endl;
	}

	~Person()
	{
		cout << "Person析构" << endl;
	}

	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	}

	string m_Name;
	Phone m_Phone;

};
void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
	//析构顺序与构造相反
	Person p("张三" , "苹果X");
	p.playGame();

}


int main() {

	test01();

	return 0;
}

#include <iostream>
using namespace std;

class Person
{
	
public:

	static int m_A; //静态成员变量

	//静态成员变量特点： 
	//1 在编译阶段分配内存
	//2 类内声明，类外初始化
	//3 所有对象共享同一份数据

private:
	static int m_B; //静态成员变量也是有访问权限的
};

//类内声明，类外初始化
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;

	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {

	test01();

	return 0;
}

#include <iostream>
using namespace std;

class Person
{

public:

	//静态成员函数特点：
	//1 程序共享一个函数
	//2 静态成员函数只能访问静态成员变量
	
	static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;   //静态成员函数可以访问静态成员变量，因为静态成员变量是共享的
		//m_B = 100; //错误，不可以访问非静态成员变量，无法确定属于哪个对象
	}

	static int m_A; //静态成员变量
	int m_B; // 
private:

	//静态成员函数也是有访问权限的
	static void func2()
	{
		cout << "func2调用" << endl;
	}
};
int Person::m_A = 10;


void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.func();
    cout << p1.m_A << endl;

	//2、通过类名
	Person::func();

	//Person::func2(); //私有权限访问不到
}

int main() {

	test01();

	return 0;
}

#include <iostream>
using namespace std;

// 成员变量和成员函数是分开存储的

class Person {
public:
	Person() {
		mA = 0;
	}
	//非静态成员变量占对象空间，属于类的对象上
	int mA;
	//静态成员变量不占对象空间，不属于类的对象上
	static int mB; 
	//函数也不占对象空间，所有函数共享一个函数实例，不属于类的对象上
	void func() {
		cout << "mA:" << this->mA << endl;
	}
	//静态成员函数也不占对象空间，不属于类的对象上
	static void sfunc() {
	}
};

// 空对象占用内存空间为1
// C++编译器会给空对象分配一个字节的内存空间，是为了区分空对象占内存的位置
// 每个空对象也会有一个独一无二的内存地址

int main() {

	cout << sizeof(Person) << endl;

	return 0;
}

#include <iostream>
using namespace std;

class Person
{
public:

	Person(int age)
	{
		// 1、解决名称冲突。当形参和成员变量同名时，可用this指针来区分
        // this指针指向被调用的成员函数所属的对象
		this->age = age;
	}

	Person& PersonAddPerson(Person p)
	{
		this->age += p.age;
		//2、返回对象本身
		return *this;
	}

	int age;
};

void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
    // 链式编程思想
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}

int main() {

	test01();

	return 0;
}

#include <iostream>
using namespace std;

//空指针访问成员函数

class Person {
public:

	void ShowClassName() {
		cout << "我是Person类!" << endl;
	}

	void ShowPerson() {
        // 如果没有if，会报错，原因是传入的指针为空指针
		if (this == NULL) {
			return;
		}
		cout << mAge << endl;
	}

public:
	int mAge;
};

void test01()
{
	Person * p = NULL;
	p->ShowClassName(); //空指针，可以调用成员函数
	p->ShowPerson();  //但是如果成员函数中用到了this指针，就不可以了
}

int main() {

	test01();

	return 0;
}

#include <iostream>
using namespace std;

class Person {
public:
	Person() {
		m_A = 0;
		m_B = 0;
	}

	//this指针的本质是一个指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
    //在成员函数后面加const，修饰的是this指针指向的内存空间，让其中的成员变量不可修改
	void ShowPerson() const {
		//const Type* const pointer;
		//this = NULL; //不能修改指针的指向 Person* const this;
		//this->m_A = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc() {
		//m_A = 10000;
	}

public:
	int m_A;
	mutable int m_B; //可修改 可变的
};


//const修饰对象  常对象
void test01() {

	const Person person; //常量对象  
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 20; //但是常对象可以修改mutable修饰成员变量
    cout << person.m_B << endl;

	//常对象访问成员函数
    person.ShowPerson();//常对象只能调用常函数
	// person.MyFunc(); //常对象不可以调用普通成员函数，因为普通成员函数可能会修改对象的数据

}

int main() {

	test01();

	return 0;
}

#include <iostream>
#include <string>
using namespace std;

//设计一个 Building类， 包含客厅( public) 和卧室( private)，
class Building
{
	//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building * building);

public:

	Building()
	{
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}


public:
	string m_SittingRoom; //客厅

private:
	string m_BedRoom; //卧室
};

//全局函数 访问 Building类中的私有内容
void goodGay(Building * building)
{
	cout << "好基友正在访问： " << building->m_SittingRoom << endl;
	cout << "好基友正在访问： " << building->m_BedRoom << endl;// 私有内容
}


void test01()
{
	Building b;
	goodGay(&b);
}

int main(){

	test01();

	return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Building;
class goodGay
{
public:

	goodGay();
	void visit(); // 参观函数 访问buliding中的属性

private:
	Building *building;
};


class Building
{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodGay;

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

// 类外实现成员函数
Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}

goodGay::goodGay()
{
	building = new Building;
}

void goodGay::visit()
{
	cout << "好基友类正在访问" << building->m_SittingRoom << endl;
	cout << "好基友类正在访问" << building->m_BedRoom << endl;
}

void test01()
{
	goodGay gg;
	gg.visit();

}

int main(){

	test01();

	return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Building;
class goodGay
{
public:

	goodGay();
	void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
	void visit2(); //不是好朋友，不能访问Building中私有内容

private:
	Building *building;
};


class Building
{
	//告诉编译器  goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
	friend void goodGay::visit();

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

//类外实现成员函数
Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}

goodGay::goodGay()
{
	building = new Building;
}

void goodGay::visit()
{
	cout << "visit正在访问" << building->m_SittingRoom << endl;
	cout << "visit正在访问" << building->m_BedRoom << endl;
}

void goodGay::visit2()
{
	cout << "visit2正在访问" << building->m_SittingRoom << endl;
	//cout << "好基友正在访问" << building->m_BedRoom << endl; //无法访问
}

void test01()
{
	goodGay  gg;
	gg.visit();
    gg.visit2();

}

int main(){
    
	test01();

	return 0;
}

#include <iostream>
using namespace std;

class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//1、成员函数实现 + 号运算符重载
	Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


public:
	int m_A;
	int m_B;
};

//2、全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
//	Person temp(0, 0);
//	temp.m_A = p1.m_A + p2.m_A;
//	temp.m_B = p1.m_B + p2.m_B;
//	return temp;
//}

//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; //相当于 operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

int main() {

	test();

	return 0;
}

#include <iostream>
using namespace std;

class Person {
	friend ostream& operator<<(ostream& out, Person& p);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现不了  p << cout 不是我们想要的效果
    //不会利用成员函数重载<<，因为无法实现cout在左侧
	//void operator<<(Person& p){
	//}

private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//ostream对象只能有一个
//本质 operator<<(cout, p) 简化 cout << p
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

void test() {

	Person p1(10, 20);

	cout << p1 << " hello world" << endl; //链式编程
}

int main() {

	test();

	return 0;
}

#include <iostream>
using namespace std;

// 自定义整型
class MyInteger {

	friend ostream& operator<<(ostream& out, MyInteger myint);

public:
	MyInteger() {
		m_Num = 0;
	}
	//前置++，返回引用为了一直对一个数据进行递增操作
	MyInteger& operator++() {
		//先++
		m_Num++;
		//再返回
		return *this;
	}

	//后置++，int为占位参数，用于区分前置++和后置++
    //返回值不引用是因为返回的是局部变量，返回局部变量后，局部变量就销毁了，所以返回值不引用
	MyInteger operator++(int) {
		//先返回
		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		m_Num++;
		return temp;
	}

private:
	int m_Num;
};

//重载<<，用于输出自定义数据类型
ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}


//前置++ 先++ 再返回
void test01() {
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++ 先返回 再++
void test02() {

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

int main() {

	test01();
	test02();

	return 0;
}

#include <iostream>
using namespace std;

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符 
	Person& operator=(Person &p)
	{
		//先判断是否有属性在堆区，有的话先释放，防止内存泄漏
        if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}


    //析构函数，释放堆区数据
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年龄的指针
	int *m_Age;

};


void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(30);

	p3 = p2 = p1; //赋值操作

	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

int main() {

	test01();

	//int a = 10;
	//int b = 20;
	//int c = 30;

	//c = b = a;
	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;
	//cout << "c = " << c << endl;

	return 0;
}