typedef void (*GL_GENBUFFER) (GLsizei,GLuint*);//声明函数指针
GL_GENBUUFFER glGenBuffer = (GL_GENBUFFER)wglGetProcAddress('glGenBuffer');//获取函数指针
unsigned int buffer;//声明缓冲区对象
glGenBuffer(1,&buffer);//调用函数

unsigned int buffer;
glGenBuffer(1,&buffer);

#include <iostream>
using namespace std;

//全局变量 
int g_a = 10;
int g_b;

//const 修饰的全局变量
const int c_g_a = 10;

int main(int argc,char *argv[]){
    //局部变量
    int a = 10;
    int b = 20;

    //静态变量
    static int s_a = 10;
    static int s_b;

    //字符串常量
    char *P = "hello world";

    //const修饰的局部变量
    const int c_l_a = 10;

    cout<<"局部变量a的地址："<<&a<<endl;
    cout<<"局部变量b的地址："<<&b<<endl;
    cout<<"全局变量a的地址："<<&g_a<<endl;
    cout<<"全局变量b的地址："<<&g_b<<endl;
    cout<<"静态变量a的地址："<<&s_a<<endl;
    cout<<"静态变量b的地址："<<&s_b<<endl;

    cout<<"字符串常量P的地址："<<P<<endl;
    cout<<"const修饰的局部变量c_l_a的地址："<<&c_l_a<<endl;
    cout<<"const修饰的全局变量c_g_a的地址："<<&c_g_a<<endl;

    return 0;
}

#include <iostream>
using namespace std;

int *GetAddr(int b){//形参数据也放在栈区
    b = 10;
    int a = 10;
    return &a;//返回局部变量的地址
}

int main(){
    int *p = GetAddr();
    cout<<*p<<endl;//第一次可以打印正确的数据，是因为编译器做了保留，
    cout<<*p<<endl;// 但是第二次访问将不再保留
    return 0;
}

#include <iostream>
using namespace std;
int* getAddr(){

    //在堆上开辟空间，并初始化为10
    int *p = new int(10);//new出来的数据返回的是一个指针
    //使用存在栈区的局部指针指向堆区的数据，栈区的内容会被程序自动释放，但是指向堆区的数据不会被释放
    return p;
}
int main(){

    int *p = getAddr();

    cout<<*p<<endl;//输出10
    delete p;//释放空间
    return 0;
}

#include <iostream>
using namespace std;
void test(){
    int *P = new int(10);
    cout<<*P<<endl;
    
    delete P;
}
void test2(){
    int *arr = new int[10];
    for(int i = 0;i<10;i++){
        arr[i] = i+10;
    }
    for(int i = 0;i<10;i++){
        cout<<arr[i]<<" ";
    }
    delete[] arr;
}
int main(){
    test();
}

//值传递
void test1(int a,int b) {

}
//地址传递
void test2(int *a,int *b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}
//引用传递
void test3(int &a,int &b) {
	int temp = a;
	a = b;
	b = temp;
}

// 二、引用做函数返回值
	//1.不能返回应用返回值
int& test04()//以引用的方式返回b,相当于给这个b起了一个别名
{
	int b = 10;//局部变量存放在栈区，函数结束后会被释放
	return b;
}
	//2. 函数的调用可以作为左值
int& test05()
{
	static int b = 10;//静态变量存放在全局区，程序结束后由系统自动释放
	return b;
}

int main() 
{
	int& ret04 = test04();
	int& ret05 = test05();
	std::cout << "ret04= "<<ret04 << std::endl;
	std::cout << "ret04= " << ret04 << std::endl;//第二次访问返回的是乱码
	std::cout << "ret05= " << ret05 << std::endl;
	test05() = 130;//函数的返回是引用，函数的调用可以作为左值
	std::cout << "ret05= " << ret05 << std::endl;

	system("pause");
	return 0;
}

//四、常量引用
	//int &ref = 10; 这样的操作是不被允许的，因为赋值给引用的是一个字面量,引用需要一个合法的空间，
	// 程序运行时没有专门为其分配可修改的内存空间
	// 但是如果在前面在上const，这条代码就通过
	// const int &ref = 10;
	//用来修饰形参，防止误操作
void test06(const int &val)
{
	//val = 100;不被允许修改
	std::cout << "val = " << val << std::endl;
}

//函数默认参数
void test(int a ,int b = 20,int c = 30)
{
	std::cout << "a = " << a << std::endl;
	std::cout << "b = " << b << std::endl;
	std::cout << "c = " << c << std::endl;
}

#include <iostream>
//函数声明
void test(int a=10,int b = 20);//
//函数实现
void test(int a ,int b)
{
	std::cout << "a = " << a << std::endl;
	std::cout << "b = " << b << std::endl;
}

//函数占位参数
void test(int a,int)//第二个参数为占位参数
{
    std::cout << "a = " << a << std::endl;
}

int main() {
    test(10,10);//占位参数必须填补,否则无法运行
}

//函数占位参数
void test(int a,int = 10)//第二个参数为占位参数，含默认值
{
    std::cout << "a = " << a << std::endl;
}

int main() {
    test(10);//不需要传站位参数
}

void fun(int &a){
    std::cout<<"fun(int &a)"<<std::endl;
}
void fun(const int &a){
    std::cout<<"fun(const int &a)"<<std::endl;
}
int main(){
    int a = 10;
    const int &b = 20;
    fun(a);//调用fun(int &a)
    fun(b);//调用fun(const int &a)
    fun(10);//调用fun(const int &a)
    return 0;
}

void fun2(int a,int b = 10){
    std::cout<<"fun(int &a)"<<std::endl;
}
void fun2(int a){
    std::cout<<"fun(const int &a)"<<std::endl;
}
int main(){

    fun2(10);//此时程序出现二义性，无法确定调用哪个函数
    return 0;
}

namespace test_class
{
	//设计一个圆的类
#define PI 3.14
	class Circle
	{
		//访问权限
	public:
		//属性
		int m_r;
		//行为
		double calculateZC()
		{
			return 2 * PI * m_r;
		}
	};
	void test() {
		Circle c1;
		c1.m_r = 10;
		cout << "圆的周长 = " << c1.calculateZC() << endl;
	}
}

namespace test_class
{
	class Person
	{
	private:
		//姓名
		string m_Name;
		//年龄
		int m_Age;
    public:
		void setAge(int age)
		{
			m_Age = age;
        }
    };
    int main(){
        Person p;
        p.setAge(18);
        return 0;
    }
}

namespace test
{
	//构造函数的分类及调用

	//分类 按照参数分：有参构造函数和无参构造函数（默认构造函数）
	//		按照类型分：普通构造和拷贝构造
	class Person
	{
		public:
			Person() {
				cout << "调用无参构造函数" << endl;
			}
			Person(int Age)
			{
				age = Age;
				cout << "调用有参构造函数" << endl;
			}
			Person(const Person &p)
			{
				age = p.age;
				cout << "调用拷贝构造函数" << endl;
			}
			~Person() {
				cout << "调用析构函数" << endl;
			}

		private:
			int age;
	};
	//调用
	void test() {
		//1.括号法
		Person p1;
		Person p2(18);
		Person p3(p2);
		//注意事项
		// 如果写的是 Person p1();那么编译器会认为是函数声明，而不会调用默认构造函数

		//2.显示法
		Person p1;
		Person p2 = Person(10);
		Person p3 = Person(p2);

		//匿名对象：只写Person (10)的形式，特点是当前行执行结束后，系统会立即回收
		// 注意2：
		// 不要使用拷贝构造函数初始化匿名对象、编译器会认为Person (p3) === Person p3;即对象声明
		//3.隐式调用
		Person p4 = 10;//隐式转换为Person p4 = Person(10);
	}
}

namespace test_copy
{
	//拷贝构造函数调用时机
	class Person
	{
	public:
		Person() {
			cout << "调用无参构造函数" << endl;
		}
		Person(int Age)
		{
			age = Age;
			cout << "调用有参构造函数" << endl;
		}
		Person(const Person& p)
		{
			age = p.age;
			cout << "调用拷贝构造函数" << endl;
		}
		int getAge() {
			return age;
		}
		~Person() {
			cout << "调用析构函数" << endl;
		}

	private:
		int age;
	};
	//1.使用一个创建好的对象初始化一个新的对象
	void test01() {
		Person p(19);
		Person p2(p);
	}
	//2.值传递方式传给函数参数传值
	void doWork01(Person p){
		cout << "值传递方式调用拷贝构造函数" << endl;
	}
	//3.以返回值的方式返回
	Person doWork02() {
		Person p1;
		cout << (int*)&p1 << endl;
		return p1;//返回时不直接返回p而是通过拷贝构造函数，拷贝一份返回给外面。当然，也有存在被编译器优化的情况
					//这个时候就不会调用拷贝构造函数
	}
	void test02() {
		Person p = doWork02();
		cout << (int*)&p << endl;
		//cout << p.getAge() << endl;
	}
}

namespace test_deepcopy
{
	class Person
	{
	public:
		Person(int age,int height);
		Person(const Person& p);
		~Person();

		int m_Age;
		int* m_Height;
	};

	Person::Person(int age,int height)
	{
		m_Age = age;
		m_Height = new int(height);//在堆区申请一块内存空间用于存储身高
		cout << "调用构有参造函数" << endl;
	}
	Person::Person(const Person& p)
	{
		m_Age = p.m_Age;
		//m_Height = p.m_Height;//这段代码就是浅拷贝操作
		m_Height = new int(*p.m_Height);//这段代码就是在堆区另申请内存空间，存储赋值过来的身高值
	}
	Person::~Person()
	{
		if (m_Height != NULL)
		{
			delete m_Height;
			m_Height = NULL;//避免野指针出现置空
		}
		cout << "调用析构函数" << endl;
	}
	void test()
	{
		Person p(18, 180);
		cout << "person年龄：" << p.m_Age << "身高：" << *p.m_Height << endl;

		// 为测试浅拷贝与深拷贝写如下代码
		Person p1(p);//在没有写拷贝构造函数中的申请内存空间情况下，程序会报错，原因是程序是浅拷贝，导致第二次调用析构函数的时候报错
		cout << "person年龄：" << p1.m_Age << "身高：" << *p1.m_Height << endl;
	}
}

namespace test_init
{
	class Person
	{
	public:
		//初始化列表
		//Person() :m_A(10), m_B(20), m_C(30) { }
		Person(int a,int b,int c) :m_A(a), m_B(b), m_C(c) { }

		~Person() {}

		int m_A;
		int m_B;
		int m_C;
		
	};
	void test() {
		Person p(10, 20, 30);
		cout << "m_A:" << p.m_A << endl;
		cout << "m_B:" << p.m_B << endl;
		cout << "m_C:" << p.m_C << endl;
	}
}

namespace test_static
{
	class Person
	{
	public:
		static int m_A;
		int m_B;
	private:
		static int m_C;
	};
	int Person::m_A = 10;
	void test01() {
		//1.通过对象访问
		Person p;
		p.m_A = 100;
		cout << "p.m_A = " << p.m_A << endl;
		cout << "p.m_B = " << p.m_B << endl;
		//2.通过类名访问
		cout << "Person::m_A = " << Person::m_A << endl;
		//cout << "Person::m_B = " << Person::m_B << endl;//报错，私有成员变量类外不可以访问
	}
}

namespace test_static_func
{
	class Person
	{
	public:
		static void func() {
			m_A = 100;//静态成员函数可以访问静态成员变量
			//m_B = 100;//静态成员函数不可以访问非静态成员变量
			cout << "static_func调用" << endl;
		
		_}
		static int m_A;
		int m_B;
	}
	int Person::m_A = 10;
	void test01() {
		//1.通过对象访问
		Person p;
		p.func();
		//2.通过类名访问
		Person::func();
	}
}

namespace test_this{
	class Person
	{
	};
	class Person2
	{
		int m_A;
		static m_B;//静态成员，不在类对象上
		void func(){}//非静态成员函数，不在类对象上【原因需要看下一节】
		static void func2(){}//静态成员函数，不在类对象上
	};
	int Person::m_B = 10;
	void test01() {
		Person p;
		//空对象占用内存为1
		//原因：C++编译器给每个空对象也分配一个字节空间，是为了区分空对象占用的内存区域，否则，空对象和字符数组无法区分
		cout << sizeof(p) << endl;//1
	}
	void test02() {
	    Preson2 p2;
		cout <<sizeof(p2)<<endl;
		//空对象占用内存为4
		//原因：此时不是5而是4，当不是空的时候，为int类型，占用4个字节
		//同时也验证了静态成员变量不属于类的对象上。
	}
}

namespace test_this{
	class Person
	{
	public:
		Person(int age) {
			age = age;
		}
		int age;
	}
	void test01() {
		Person p(19);
	     cout<<"age:"<<p.age<<endl;
	}
}

namespace test_this{
	class Person
	{
	public:
		Person(int age) {
			this->age = age;
		}
		int age;
	}
	void test01() {
		Person p(19);
	     cout<<"age:"<<p.age<<endl;
	}
}

namespace test_this {
    class Person {
    public:
        // 修改1：添加类定义结尾的分号
        void addAge(int age) {
            this->m_Age += age;
        }
        int m_Age = 10;
    };  // 修正：补充分号

    void test01() {
        Person p;
        p.addAge(10);
        // 修改2：void 返回值无法输出，需直接访问成员变量
        cout << "age:" << p.m_Age << endl;  // 输出 20
    }
}

namespace test_this {
    class Person {
    public:
        // 返回引用以实现链式调用
        Person& addAge(int age) {
            this->m_Age += age;
            return *this; // 返回对象本身的引用
        }
        int m_Age = 10;
    };

    // 修改3：重载 operator<< 以支持输出 Person 对象
    ostream& operator<<(ostream& os, const Person& p) {
        os << p.m_Age;
        return os;
    }

    void test01() {
        Person p;
        // 链式调用操作的是同一个对象（p）
        p.addAge(10).addAge(10).addAge(10);
        cout << "p.m_Age: " << p.m_Age << endl; // 输出 40
    }
}

Person addAge(int age) { /* ... */ } // 返回副本

Person p;
p.addAge(10).addAge(10);  // 第二个 addAge 操作的是临时副本
cout << p.m_Age;          // 输出 20（仅第一次修改生效）

namespace test_nullptr {
    class Person {
    public:
        void showClassName() {
            cout << "this is Person class" << endl;
        }
        void showPersonAge() {
			//报错的原因是因为传入的指针是空指针，空指针访问成员变量会报错，解决办法如下:
			// if(this == NULL){
			// 	return;
			// }
            cout << "age = " << m_Age << endl;//这条代码的本质：cout << "age = " << this->m_Age << endl;
        }
		int m_Age;
	};
	void test01() {
	    Person *P = NULL;
		p->showClassName();//不报错
		p->showPersonAge();//报错，空指针访问成员变量
	}
}

namespace test_const{
//常函数
class Person{
	public:
	//this指针的本质是指针常量，指针指向的内容不可以修改
	//Person * const this
	//如果在成员函数后写了const，那么上面的语句就变成：
	//const Person * const this
	//在成员函数的后面加const，本质上是修饰了this指针，让this指针指向的值不可修改
		void showPerson() const
		{
			//this->m_A = 100;//常函数不可以修改成员变量
			m_B = 100;//在变量前加mutable，让这个变量永远可变
		}
		void func(){
			cout<<"func调用"<<endl;
		}
		int m_A;
		mutable int m_B;//在变量前加mutable，让这个变量永远可变
}
void test01() {
    Person p;
	p.showPerson();
}
//常对象
void test02() {
    const Person p;
	//p.m_A = 100;//常对象不可以修改成员变量
	p.m_B = 100;//可以调用
	p.showPerson();//可以调用
	p.func();//可以调用
}
}

namespace test_friend{
	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;
	};
	void GoodGay(Building &buiding){
		cout<<"好基友正在访问"<<buiding.m_SittingRoom<<endl;
		cout<<"好基友正在访问"<<buiding.m_BedRoom<<endl;
	}
	void test01(){
	    Building buiding;
		GoodGay(buiding);
	}
}

namespace test_friend{
	class Building;//先写出来防止报错
	class GoodGay{
		public:
			GoodGay();
			void visit();//参观函数访问Building中的成员
			Building *m_Building;//让该类有访问Building的权限
	};
	class Building{
		friend class GoodGay;//告诉编译器GoodGay类是Building的好朋友，可以访问Building的私有内容
		public:
			Building();//构造函数
		public:
			string m_SittingRoom;
		private:
		    string m_BedRoom;
	};
	GoodGay::GoodGay(){
		this->m_Building = new Building();//在对象被初始化时，就创建一个Building对象，方便后续访问Building中的成员
	}
	Building::Building(){//当building对象被创建的时候，给变量初始化
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}
	void GoodGay::visit(){
		cout<<"好基友正在访问："<<this->m_Building.m_SittingRoom<<endl;
		cout<<"好基友正在访问："<<this->m_Building.m_BedRoom<<endl;//在没有声明GoodGay为Building的友元类时，这句代码不通过。
	}
	void test01(){
		GoodGay gg;
		gg.visit(); 
	}
}

三、成员函数做友元

作用：

```cpp
namespace test_friend{
	class Building;
	class GoodGay{
		public:
			GoodGay();
			void visit();//参观函数访问Building中的成员
			void visit2();//让参观函数不可以访问访问Building中的成员
			Building *building;//让该类有访问Building的权限
	};
	class Building{
		//告诉编译器GoodGay类中的visit成员函数是Building好朋友，可以访问Building的私有内容
		friend void GoodGay::visit();
		public:
			Building();//构造函数
		public:
			string m_SittingRoom;
		private:
		    string m_BedRoom;
	};
	Building::Building(){
		m_SittingRoom = "客厅";
		m_BedRoom ="卧室";

	}
	GoodGay::GoodGay(){
		building = new Building();//在对象被初始化时，就创建一个Building对象
	}
	void GoodGay::visit(){
		cout<<"好基友正在访问："<<building->m_SittingRoom<<endl;
		cout<<"好基友正在访问："<<building->m_BedRoom<<endl;
	}
	void GoodGay::visit2(){
		cout<<"好基友正在访问："<<building->m_SittingRoom<<endl;
	}
	void test01(){
		GoodGay gg;
		gg.visit();
		gg.visit2();
	}
}

namespace test_add
{
	class Person
	{
	public:
		//1、成员函数重载
		/*Person operator+ (Person &p)
		{
			Person temp;
			temp.m_A = this->m_A + p.m_A;
			temp.m_B = this->m_B + p.m_B;
			return temp;
		}*/
		int m_A;
		int m_B;

	};
	Person operator+(Person& p1, Person& p2)
	{
		Person temp;
		temp.m_A = p1.m_A + p2.m_A;
		temp.m_B = p1.m_B + p2.m_B;
		return temp;
	}
	void test() {
		Person p1;
		p1.m_A = 20;
		p1.m_B = 10;
		Person p2;
		p2.m_A = 20;
		p2.m_B = 10;
		//本质:Person ret = p2.operator+(p1)或者Person ret = operator+(p2,p1);简化为如下写法：
		Person p3 = p1 + p2;

		cout << "结果：" << p3.m_A << endl;
		cout << "结果：" << p3.m_B << endl;
	}
}

namespace test_LeftMove
{
	class Person
	{
		//使用友元思想实现类外函数访问类内私有成员
		friend ostream& operator<<(ostream& cout, Person& p);
	public:
		Person(int a,int b):m_A(a),m_B(b){}
		private://数据一般为私有
			int m_A;
			int m_B;
	};
	//此处传入的值与返回的值都是用引用，对于ostream& cout是唯一的，
	// 所以使用引用，ostream&作为返回值类型是为了实现链式输出
	//即：cout << p << endl;
	ostream& operator<<(ostream& cout, Person &p)
	{
		cout << "m_A = " << p.m_A << "  m_B = " << p.m_B;
		return cout;
	}
	void test() {
		Person p(10,20);
		cout << p << endl;
	}
}

namespace test_MyInteger {
	class MyInteger
	{
		friend ostream& operator<<(ostream& cout, const MyInteger& myint);
	public:
		MyInteger(){
			Integer = 0;
		}
		//前置运算符
		MyInteger& operator++() {
			Integer++;
			return *this;
		}
		//后置运算符
		MyInteger operator++(int)//int是占位符，用于区分是前置还是后置运算符
		{
			MyInteger myint = *this;//记录当前值
			Integer++;//对象属性自增
			return myint;//返回记录值而不是自增后的值
		}
	private:
		int Integer;
	};
	ostream& operator<<(ostream& cout, const MyInteger& myint)
	{
		cout << myint.Integer;
		return cout;
	}
	
	void test1() {
		MyInteger myint;
		cout << ++(++myint) << endl;//如果返回的不是引用，那么这里的++(++myint)也能通过，但是并不是在原来的对象上进行操作，而是一个新的对象上操作。
		cout << myint << endl;
	}
	void test2() {
		MyInteger myint;
		cout << (myint++)++ << endl;//这样的操作精良避免发生，这不符合C++语法，因为第二次自增是在临时对象上自增而不是原始对象。
		cout << myint << endl;
	}

}

namespace test_assig
{
	class Person
	{
	public:
		Person(int age) {
			m_Age = new int(age);
		}

		~Person() {
			if (m_Age != NULL)
			{
				delete m_Age;
				m_Age = NULL;
			}
		}
		Person& operator=(Person &p) {
			//默认赋值语句
			//m_Age= p.age;

			//先判断是否有属性在堆区，如果有先删除干净，再深拷贝
			if (m_Age != NULL)
			{
				delete m_Age;
				m_Age = NULL;
			}
			//深拷贝
			m_Age = new int(*p.m_Age);

			return *this;
		}
		int* m_Age;

	};
	void test() {
		Person p1(18);
		Person p2(20);
		Person p3(90);

		p3=p1 = p2;

		cout << *p1.m_Age << endl;
		cout << *p2.m_Age << endl;
		cout << *p3.m_Age << endl;

	}
}

namespace test_relation
{
	class Person
	{
	public:
		Person(string name, int age)
		{
			m_Name = name;
			m_Age = age;
		}
		bool operator==(Person& p)
		{
			if (m_Age == p.m_Age && m_Name == p.m_Name)
			{
				return true;
			}
			else {
				return false;
			}
		}
		int m_Age;
		string m_Name;

	};
	void test()
	{
		Person p1("JUN", 18);
		Person p2("JUN", 18);

		if (p1 == p2)
		{
			cout << "p1与p2相等" << endl;
		}
		else
		{
			cout << "p1与p2不相等" << endl;
		}
	}
}

namespace test_call
{
	class MyPrint
	{
	public:
		void operator()(string text)
		{
			cout << text << endl;
		}
		void operator()(int a, int b)
		{
			cout << a + b << endl;
		}
	};
	void test()
	{
		MyPrint myprint;
		myprint("hello world");
		myprint(1, 2);
		cout<<MyPritn()("hello world")<<endl;//MyPritn()是匿名对象，作用域在当前行，所以输出后立即销毁
	}
}

class 子类 : 继承方式 父类
{
	//类体
};

namespace test_model
{
	class Base {
	public:
		int m_A;
	protected:
		int m_B;
	private:
		int m_C;
	};
	class Son :public Base {
	public:
		int m_D;
	};
	void test(){
		cout<<"sizeof(Base) = "<<sizeof(Base)<<endl;
	}
}

namespace test_construct_destruct{
	class Base{
		public:
			Base(){
				cout<<"Base构造函数"<<endl;
			}
			~Base(){
				cout<<"Base析构函数"<<endl;
			}
	};
	class Son:public Base{
		public:
			Son(){
				cout<<"Son构造函数"<<endl;
			}
			~Son(){
				cout<<"Son析构函数"<<endl;
			}
	}
}

Base构造函数
Son构造函数
Son析构函数
Base析构函数

namespace test_same_name{
	class Base{
		public:
			Base()
			{
				m_A = 100;
			}
			void func(){
				cout<<"Base func()"<<endl;
			}
			void func(int a){
				cout<<"Base func(int a)"<<endl;
			}
			int m_A;
	};
	class Son:public Base{
		public:
			Son()
			{
				m_A = 200;
			}
			void func(){
				cout<<"Son func()"<<endl;
			}
			int m_A;
	};
	//同名的成员属性
	void test01(){
		Son s;
		cout<<s.m_A<<endl;
		cout<<s.Base::m_A<<endl;
	}
	//同名的函数
	void test02(){
		Son s;
		s.func():
		s.Base::func();//通过作用域解决

		//下面的代码不通过，因为当子类和父类存在相同函数名时，子类的同名函数会屏蔽父类的同名函数，要想访问父类的同名函数，需要加作用域
		//s.func(10);
	}
}

namespace test_same_static{
	class Base{
		public:
			static int m_A;
			static void func(){
				cout<<"Base func()"<<endl;
			}
	};
	class Son:public Base{
		public:
			static int m_A;
			static void func(){
				cout<<"Son func()"<<endl;
			}
	};


	int Base::m_A = 100;
	int Son::m_A = 200;
	//同名的静态成员属性
	void test01(){
		Son s;

		//通过对象访问
		cout<<s.m_A<<endl;
		cout<<s.Base::m_A<<endl;

		//通过类名访问
		cout<<Son::m_A<<endl;
		cout<<Son::Base::m_A<<endl;
	}
	//同名的静态成员函数
	void test02(){
		Son s;
		s.func();
		s.Base::func();

		//通过对象访问
		Son::func();
		Son::Base::func();
	}
}

namespace test_multi_inherit{
	class Base1{
		public:
			Base1(){
				m_A = 100;
				cout<<"Base1构造函数"<<endl;
			}
			int m_A;
	}；
	class Base2{
		public:
			Base2(){
				m_A = 200;
				cout<<"Base2构造函数"<<endl;
			}
			int m_A;
	};
	class Son:public Base1,public Base2{
		public:
			Son(){
				m_A = 300;
				m_B = 400;
				cout<<"Son构造函数"<<endl;
			}
			int m_A;
			int m_B;
	};
	void test(){
		Son s;//调用Base1构造函数，再调用Base2构造函数，最后调用Son构造函数
	}
}

namespace test_diamond_inherit {
	//动物类
	class Animal {
	public:
		int m_Age;
	};
	//利用虚继承可以解决菱形继承的问题
	//在继承之前加virtual
	//羊类
	class Sheep :virtual public Animal {
	};
	//驼类
	class Tuo :virtual public Animal {
	};
	//羊驼类
	class SheepTuo :public Sheep, public Tuo {
	};
	void test() {
		SheepTuo st;
		//当菱形继承，连个父类拥有相同的数据时，需要加作用域加以区分
		st.Sheep::m_Age = 10;
		st.Tuo::m_Age = 20;

		
		cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
		cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
		//当添加virtual关键字后，就可以使用下面的语句，而且不会出现二义性
		cout << "st.m_Age = " << st.m_Age << endl;
	}
}

namespace test_polymorphism
{
	class Animal
	{
		public:
		virtual void speak()
		{
			cout << "动物在说话" << endl;
		}
	};
	class Cat :public Animal
	{
		public:
		void speak()
		{
			cou<<"喵喵喵"<<endl;
		}
	};
	void doSpeak(Animal & animal)//父类的指针可以指向子类的对象
	{
		animal.speak();
	}
	void test(){
		Cat cat;
		doSpeak(cat);//在未添加virtual关键字时，输出的是:动物在说话，添加后输出的是:喵喵喵,原因是未添加前，在编译阶段确定了speak()函数地址，而添加后，程序运行阶段才确定speak()函数地址
	}
}

namespace test_polymorphism
{
	class Animal
	{
		public:
		virtual void speak()
		{
			cout << "动物在说话" << endl;
		}
	};
	class Cat :public Animal
	{
		public:
		void speak()
		{
			cou<<"喵喵喵"<<endl;
		}
	};
	void doSpeak(Animal & animal)//父类的指针可以指向子类的对象
	{
		animal.speak();
	}
	void test01(){
		Cat cat;
		doSpeak(cat);
	}
	void test02(){
	    cout<<sizeof(Animal)<<endl;
	}
}

//计算器抽象类
class AbstractCalculator
{
public:
	virtual int getResult()
	{	
		return 0;		
	}
	virtual string reOperator()
	{
		return " ";
	}
	int m_Num1;
	int m_Num2;
};

ostream& operator<<(ostream &cout, AbstractCalculator &abc)
{
	cout << abc.m_Num1 << abc.reOperator() << abc.m_Num2 << "=" << abc.getResult();
	return cout;
}
//加法类
class AddCalculator :public AbstractCalculator
{
public:
	AddCalculator(int a,int b){
		m_Num1 = a;
		m_Num2 = b;
	}
	int getResult()
	{
		return m_Num1 + m_Num2;
	}
	string reOperator()
	{
		return "+";
	}
};
void test01()
{
	AbstractCalculator *abc = new AddCalculator(1,2);
	cout << *abc << endl;
	delete abc;
}

//多态-纯虚函数和抽象类
namespace test_pvfAndAbc
{
	class Base
	{
		//纯虚函数，该类为抽象类
		//1.无法实例化对象
		//2.子类必须重写父类的纯虚函数
	public:
		virtual void func() = 0;
	};
	class Son :public Base
	{
	public:
		void func()
		{
			cout << "func()" << endl;
		}
	};
	void test01() {
		//Base b;抽象类无法实例化对象
		//new Base; 抽象类无法实例化对象
		//Son s;在没有重写抽象类时，无法实例化对象
		Base *base = new Son;
		base->func();
	}
}

//纯虚函数案例
class AbstractDrinking
{
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入
	virtual void PourInCup() = 0;
	//加入辅料
	virtual void PutSomething() = 0;
	//制作饮品
	void makeDrink()
	{
		Boil();
		Brew();
		PourInCup();
		PutSomething();
	}
};
class Coffer :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮矿泉水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "热水冲泡咖啡" << endl;
	}
	//倒入
	virtual void PourInCup()
	{
		cout << "倒入杯子" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入冰块与牛奶" << endl;
	}
};

class Tea :public AbstractDrinking
{
public:
	//煮水
	virtual void Boil()
	{
		cout << "煮泉水" << endl;
	}
	//冲泡
	virtual void Brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	//倒入
	virtual void PourInCup()
	{
		cout << "倒入杯子" << endl;
	}
	//加入辅料
	virtual void PutSomething()
	{
		cout << "加入红枣" << endl;
	}
};
void doWork(AbstractDrinking* abd)
{
	abd->makeDrink();
	delete abd;
}
void test01() {
	//制作咖啡
	doWork(new Coffer);

	cout << "---------------"<<endl;
	//制作茶
	doWork(new Tea);
}

namespace test_pureVirtualDestructor
{
	class Animal
	{
	public:
		Animal()
		{
			cout << "Animal构造函数调用" << endl;
		}
		virtual void speak() = 0;
		//下面的写法是虚析构函数
		/*~Animal()
		{
			cout << "Animal析构函数调用" << endl;
		}*/
		//下面的写法是纯虚析构函数
		//这种写法需要类内声明类外实现
		virtual ~Animal() = 0;
	};
	Animal::~Animal()
	{
		cout << "Animal析构函数调用" << endl;
	}
	class Cat :public Animal
	{
	public:
		Cat(string name)
		{
			cout << "Cat构造函数调用" << endl;
			m_Name = new string(name);
		}
		void speak() {
			cout <<*m_Name<< "在喵喵喵" << endl;
		}
		~Cat()
		{
			cout << "Cat析构函数调用" << endl;
			if (m_Name != NULL)
			{
				delete m_Name;
				m_Name = NULL;
			}
		}
		//假设现在使用一个指针来管理猫的名字
		string * m_Name;
	};
	void test01() {
		//父类执政在析构时候不会调用子类中的析构函数，
		// 导致子类如果子类有堆区的数据，将无法释放。
		Animal* anm = new Cat("Tom");
		anm->speak();
		delete anm;
	}
}

Animal构造函数调用
Cat构造函数调用
Tom在喵喵喵
Animal析构函数调用

Animal构造函数调用
Cat构造函数调用
Tom在喵喵喵
Cat析构函数调用
Animal析构函数调用

namespace test_computer
{
	//抽象不同零件类
	class CPU
	{
	public:
		virtual void calculate() = 0;
	};
	class VideoCard
	{
	public:
		virtual void display() = 0;
	};
	class Memory
	{
	public:
		virtual void storage() = 0;
	};
	//组装电脑的类
	class Computer
	{
	public:
		Computer(CPU* cpu, VideoCard* vc, Memory* mem)//父类的指针，在此处已经涉及多态了
		{
			m_cpu = cpu;
			m_vc = vc;
			m_mem = mem;
		}
		//工作的函数
		//调用接口
		void work()
		{
			m_cpu->calculate();
			m_vc->display();
			m_mem->storage();
		}
		~Computer()
		{
			if (m_cpu != NULL)
			{
				delete m_cpu;
				m_cpu = NULL;
			}
			if (m_vc != NULL)
			{
				delete m_vc;
				m_vc = NULL;
			}
			if (m_mem != NULL)
			{
				delete m_mem;
				m_mem = NULL;
			}
		}
	private:
		CPU* m_cpu;
		VideoCard* m_vc;
		Memory* m_mem;
	};
	class IntelCPU :public CPU
	{
	public:
		void calculate()
		{
			cout << "IntelCPU开始计算" << endl;
		}

	};
	class IntelVideoCard :public VideoCard
	{
	public:
		void display()
		{
			cout << "IntelVideoCard开始显示" << endl;
		}
	};
	class LenoMemory :public Memory
	{
	public:
		void storage()
		{
			cout << "LenoMemory开始存储" << endl;
		}
	};
	void test01() {
		//创建具体品牌的对象
		CPU* intelCpu = new IntelCPU;
		VideoCard* intelVc = new IntelVideoCard;
		Memory* lenoMem = new LenoMemory;
		//创建电脑对象
		Computer* computer = new Computer(intelCpu, intelVc, lenoMem);
		//电脑开始工作
		computer->work();
		//释放资源
		delete computer;
	}
}

//写文件
namespace test_write
{
	//写文本
	void test01()
	{
		//1.包含头文件

		//2.创建流对象
		ofstream ofs;

		//3.制定一个打开的方式
		ofs.open("text.txt", ios::out);
		//4.写内容
		ofs << "姓名：张三" << endl;
		ofs << "性别：男" << endl;
		ofs << "年龄：18" << endl;

		//5.关闭文件
		ofs.close();
	}
	//写二进制文件
	class Person
	{
	public:
		char m_Name[64];
		int m_Age;
	};
	void test02() {
		//1.包含头文件
		//2.创建流对象
		ofstream ofs("person.txt", ios::out | ios::binary);
		//3.打开文件
		//ofs.open("person.txt", ios::out | ios::binary);
		//4.写文件
		Person p = { "zhangsan",18 };
		ofs.write((const char*)&p, sizeof(Person));

		//5.关闭文件
		ofs.close();
	}
}
//读文件
namespace test_read
{
	//读文本
	void test01()
	{
		//1.包含头文件

		//2.创建流对象
		ifstream ifs;

		//3.制定一个打开的方式，判断打开是否成功
		ifs.open("text.txt", ios::in);
		if ( !ifs.is_open() )
		{
			cout << "文件打开失败" << endl;
			return;
		}
		//4.读内容
		//（1）
			/*char buf[1024] = { 0 };
			while (ifs >> buf)
			{
				cout << buf << endl;
			}*/
		//(2)
			/*char buf[1024] = { 0 };
			while (ifs.getline(buf, 1024))
			{
				cout << buf << endl;
			}*/
		//(3)
			string buf;
			while (getline(ifs, buf)) {
				cout << buf << endl;
			}
		//(4)不推荐这种方法
			/*char c;
			while ((c = ifs.get()) != EOF)
			{
				cout << c ;
			}*/

		//5.关闭文件
		ifs.close();
	}

	//读二进制文件
	class Person
	{
	public:
		char m_Name[64];
		int m_Age;
	};
	void test02() {
		//1.包含头文件

		//2.创建流对象
		ifstream ifs;

		//3.制定一个打开的方式，判断打开是否成功
		ifs.open("person.txt", ios::in|ios::binary);
		if (!ifs.is_open())
		{
			cout << "文件打开失败" << endl;
			return;
		}
		//4.读内容
		Person p;

		ifs.read((char*)&p, sizeof(Person));
		cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;

		//5.关闭文件
		ifs.close();
	}
}

class A{
    int a;
    public:
        A(){std::cout<<"hello\n";}//1
        A(int b){std::cout<<"value: "<<b<<std::endl;}//2
}
int main(){
    A arr[2] = {1};
}

    class CMyclass {
    public:
    ~CMyclass() { cout << "destructor" << endl; }
    };
    CMyclass obj;
    CMyclass fun(CMyclass sobj ) { //参数对象消亡也会导致析
    //构函数被调用
    return sobj; //函数调用返回时生成临时对象返回
    }
    int main(){
    obj = fun(obj); //函数调用的返回值（临时对象）被
    return 0; //用过后，该临时对象析构函数被调用
    }

class Complex {
public:
double real, imag;
void Print() { cout << real << "," << imag ; }
Complex(double r,double i):real(r),imag(i)
{ }
Complex AddOne() {
this->real ++; //等价于 real ++;
this->Print(); //等价于 Print
return * this;
}
}; 

int main() {
Complex c1(1,1),c2(0,0);
c2 = c1.AddOne();//调用AddOne函数后内部this指针变为c1，所以是c1中的read++
return 0;
} //输出 2,1

    class A
{
int i;
public:
void Hello() { cout << i << "hello" << endl; }
}; // 翻译为void Hello(A * this ) { cout << this->i << "hello"<< endl; }
int main()
{
A * p = NULL;
p->Hello(); //翻译为Hello(p);
} //编译报错

class Dog {
public:
    // 普通成员函数
    void bark() {
        std::cout << "Woof!" << std::endl;
    }

    // 静态成员函数
    static std::string getSpecies() {
        return "Canine";
    }
};

    class A
    {
    public:
    A() { cout << "default" << endl; }
    A(A & a) { cout << "copy" << endl;}
    };

    class B { A a; };

    int main()
    {
    B b1,b2(b1);//b2调用自生默认复制构造函数，而内部的A a也会调用默认的复制构造函数
    return 0;
    }

    class CTest
    {
    public:
    bool GetData() const
    {
    m_n1++;//这个值更可以更改
    return m_b2;
    }
    private:
    mutable int m_n1;
    bool m_b2;
    };

    String & operator = (const String & s){
        if( this == & s)
            return * this;
        delete [] str;
        str = new char[strlen(s.str)+1];
        strcpy( str,s.str);
        return * this;
    }

class CDemo {
private :
int n;
public:
CDemo(int i=0):n(i) { }
CDemo & operator++(); //用于前置形式
CDemo operator++( int ); //用于后置形式
operator int ( ) { return n; }
friend CDemo & operator--(CDemo & );
friend CDemo operator--(CDemo & ,int);
}

Demo s;
(int) s ; //等效于 s.int();

class Father {
private: int nPrivate; //私有成员
public: int nPublic; //公有成员
protected: int nProtected; // 保护成员
};
class Son :public Father{
void AccessFather () {
nPublic = 1; // ok;
nPrivate = 1; // wrong
nProtected = 1; // OK，访问从基类继承的protected成员
Son f;
f.nProtected = 1; //ok，派生类的成员函数可以访问当前对象和其它对象的基类的保护成
}
};

int main(){
    Father f;
    Son s;
    f.nPublic = 1; // Ok
    s.nPublic = 1; // Ok
    f.nProtected = 1; // error，因为只能在派生类（或友元类）中访问
    f.nPrivate = 1; // error
    s.nProtected = 1; //error
    s.nPrivate = 1; // error
    return 0;
}

    class Bug {
    private :
    int nLegs; int nColor;
    public:
    int nType;
    Bug ( int legs, int color);
    void PrintBug (){ };
    };

    class Skill {
    public:
    Skill(int n) { }
    };

    class FlyBug: public Bug {
    int nWings;
    Skill sk1, sk2;
    public:
    FlyBug( int legs, int color, int wings);
    };

    FlyBug::FlyBug( int legs, int color, int wings):
    Bug(legs,color),sk1(5),sk2(color) ,nWings(wings) { }//注意这种写法。

    Base * ptrBase = &objDerived;
    Derived *ptrDerived = (Derived * ) ptrBase;

    #include <iostream>
    using namespace std;
    class A {
    public: virtual void Func() { cout << "A::Func" << endl; }
    };
    class B:public A {
    public: virtual void Func() { cout << "B::Func" << endl; }
    };
    int main() {
    A a;
    A * pa = new B();
    pa->Func();
    //64位程序指针为8字节
    long long * p1 = (long long * ) & a;
    long long * p2 = (long long * ) pa;
    * p2 = * p1;
    pa->Func();
    return 0;
    }

    A a ; // 错，A 是抽象类，不能创建对象
    A * pa ; // ok,可以定义抽象类的指针和引用
    pa = new A ; //错误, A 是抽象类，不能创建对象

// 到char的hconst指针
char *const cp;
char const* pc;
// 到const char的指针
const char* pc2;
//到const char的指针

void f(){
    int ii=1;
    int &rr = ii;
    rr++;//实际上是ii++,rr不能像指针一样操作。
    int *pp = ⅈ
}