#include<iostream>
using namespace std;

//全局变量：不在函数体中定义的变量
int c = 0;
int d = 0;

//const修饰的全局变量(全局常量)
const int g = 0;

int main()
{
	//全局区

	//全局变量、静态变量，常量


	//局部变量：在函数体内定义的变量
	int a = 0;
	int b = 0;
	cout << "局部变量a的地址为：" << (int)&a << endl;
	cout << "局部变量b的地址为：" << (int)&b << endl;

	cout << "全局变量c的地址为：" << (int)&c << endl;
	cout << "全局变量d的地址为：" << (int)&d << endl;
	

	//静态变量：在普通变量的前面加 static
	static int e = 0;
	static int f = 0;

	cout << "静态变量e的地址为：" << (int)&e << endl;
	cout << "静态变量f的地址为：" << (int)&f << endl;

	//常量： 字符串常量；const修饰的常量

	//const修饰的局部变量
	const int h = 0;//（局部常量）
	cout << "字符串常量的地址为：" << (int)&"123456" << endl;
	cout << "全局常量的地址为：" << (int)&g << endl;
	cout << "局部常量的地址为：" << (int)&h << endl;//不在全局区


	//总结：在局部的和局部常量都不在全局区，全局变量，静态变量，字符串常量，全局常量在全局区
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

int* func(int b)//形参数据也会放在栈区
{
	b = 100;
	int a = 10;//局部变量	存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;//返回局部变量地址
}

//开辟堆区
int* func1()
{
	//利用new关键字，可以将数据开辟到堆区
	//指针p是局部变量，而指针保存的数据是放在堆区
	int* p = new int(100);
	
	return p;
}


int main2()
{
	//程序运行后：会划分栈区和堆区
	
	//栈区：由编译器自动分配释放，存放函数的参数值，局部变量等；
	//注意：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放(野指针警告)
	int b=0;
	int* p = func(b);		
	cout << *p << endl;		//第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p << endl;		//第二次这个数据就不再保留了(vs2022在64位的情况下对返回值进行了优化，进行了保留)

	//堆区	由程序员分配释放，若程序员不释放，程序结束时由操作系统回收
	//在C++中主要利用new在堆区开辟内存

	int* p1 = func1();//指针已经捕获了在堆区的地址，所以在栈区的指针变量即使被释放也不影响
	cout << *p1 << endl;	
	cout << *p1 << endl;
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

int* func10()//利用new操作符在堆区开辟数据
{
	int* p = new int(5201314);
	return p;
}

void test01()
{
	int* p = func10();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	//堆区由程序员分配释放,可以手动释放，使用操作符：delete
	delete p;
	//cout << *p << endl;	如果这个时再访问就是非法操作（野指针）
}

//在堆区利用new开辟数组：利用[]
void test02()
{
	int* arr = new int[10];//10代表10个元素,返回的是数组的首地址

	for (int a = 0; a < 10; a++) { arr[a] = a+100; }
	for (int a = 0; a < 10; a++) { cout << arr[a]<<endl; }
	//释放堆区数组的时候，要加[]
	delete[]arr;
}
int main()
{
	//C++中利用new操作符在堆区开辟数据
	//可以手动释放，使用操作符：delete
	//利用new创建数据，会返回该数据对应的类型的指针

	test01();
	test02();
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

int main0()
{
	//引用：给变量起别名，别名和原名都代表同一个内存空间
	//语法：数据类型 &别名 =原名
	int a = 10;
	int& b = a;
	b = 20;
	cout << a << endl;

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

int main1()
{
	//引用必须初始化	
	//引用在初始化后，不可以改变,可以赋值	（一旦代表一段内存空间后就不可更改）

	int a = 10;		//int& b;是错误的
	int& b = a;		//int& b = c;是错误的
	b = 20;
	cout << a << endl;

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

void A(int& a, int& b)//引用传递（引用做形参的时候不用初始化）
{
	int temp;
	temp = a;
	a = b;
	b = temp;

}
int main3()
{
	//函数传参时，可以利用引用的技术让形参修饰实参
	//可以简化指针修改实参
	int a = 10;
	int b = 20;
	A(a, b);
	cout << a << endl;
	cout << b << endl;
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//引用做函数返回值
//1.不要返回局部变量的引用
int& test02()
{
	int a = 0;//局部变量存放在栈区
	return a;

}

//函数的调用可以作为左值
int& test03()
{
	static int a = 0;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放(生命周期加长)
	return a;

}
int main4()
{
	int& ref = test02();

	cout << ref << endl;	//第一次可以打印正确的数字，是因为编译器做了保留
	cout << ref << endl;

	int& ref2 = test03();//ref02已经是test03的别名
	cout << ref2 << endl;
	cout << ref2 << endl;

	test03() = 1000;//如果函数的返回值是引用，这个函数调用可以作为左值

	cout << ref2 << endl;
	cout << ref2 << endl;

	system("pause");
	return 0;
}

//发现是引用，转换为 int* const ref = &a;
void func(int& ref){
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
	int a = 10;
    
    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a; 
	ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
    
	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;
    
	func(a);
	return 0;
}

#include<iostream>
using namespace std;

//打印函数
void ab(const int& a)//常量引用，引用可修改，常量不可修改
{
	//a=1000;不可修改，防止误操作
	cout << a << endl;
}
int main()
{
	//常量引用
	//使用场景：用来修饰形参，防止误操作
	int a = 10;

	//int &a = 10;引用必须引向一块合法内存空间

	//加上const之后，编译器将代码修改，int temp =10; const int & ref =temp;	(temp指的是一块临时空间)
	const int& ref = 10;

	//ref=10；const之后，改为只读，不可修改
	ab(a);

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//函数的默认参数(如果没有传入参数，则使用默认使用形参的默认值)
//语法 ：返回值类型 函数名 （形参 = 默认值）{}

int func(int a, int b=20, int c=30)//注意：如果某个位置已经有了默认值，那么从这个位置往后，从左到右都必须有默认值
{
	return a + b + c;
}
//注意：如果某个位置已经有了默认值，那么从这个位置往后，从左到右都必须有默认值
//int func1(int a, int b = 20, int c)//会报错

//注意：如果函数声明有默认参数，函数实现就不能有默认参数（会重复定义默认参数，声明和实现只能一个有默认参数）

int func2(int a, int b=30);
//int func2(int a=10, int b){}

int main0()
{
	cout << func(10) << endl;

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//占位参数
//返回值类型 函数名 (数据类型){}

//目前阶段的占位参数我们还用不到，后面函数重载会用到
//占位参数也可以有默认参数《更没有用了(滑稽)》
void func4(int a,int,int =10){}

int main1()
{
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//函数重载
//可以使函数名相同，提高复用性

//函数重载的满足条件
// 1.同一个作用域下（全局或者其他）
// 2.函数名称相同
// 3.函数的参数类型不同，或者个数不同，或者顺序不同	-》根据不同的调用参数，会自动使用对应的函数
//
void func5()
{
	cout << "funf5的调用" << endl;
}

void func5(int a)
{
	cout << "funf5(int a)的调用2" << endl;
}

void func5(double a)
{
	cout << "funf5(double a)的调用3" << endl;
}

void func5(double a,int b)
{
	cout << "funf5(double a,int b)的调用3" << endl;
}

void func5( int b,double a)
{
	cout << "funf5( int b,double a)的调用3" << endl;
}
//注意：函数的返回值类型不可以作为函数重载的条件(因为如果参数相同，就无法区分调用哪个函数内容，因为返回值可以不接收输出)
void A()
{cout << "funf5的调用" << endl;}
//int A(){cout << "funf5的调用" << endl;}

int main4()
{
	func5();
	func5(10);//根据不同的调用参数，会自动使用对应的函数
	func5(10.0);
	func5(10.0,1);
	func5(1,10.0);

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//函数重载注意事项
//1.引用作为重载条件
//void func6(int a){cout << "func6(int a)的引用" << endl;}有引用这个类型的时候不能定义相同类型的形参

void func6(int& a)//int& a =10;不合法
{
	cout << "func6(int& a)的引用" << endl;
}

void func6(const int& a)//a的数据被传进来后只能读不能写
{
	cout << "func6(const int& a)的引用" << endl;//const int& a =10;合法，会创造一个临时空间存放数据，并引向临时空间
}


//2.函数重载碰到默认参数（会出现二义性（歧义））语法本身没有问题，不调用就不会报错，写重载的时候尽量避免写默认参数
void func7(int a)
{
	cout << "func(int a)的引用" << endl;
}
\
void func7(int a,int b=10)
{
	cout << "func(int a,int b=10)的引用" << endl;
}
int main()
{
	int a = 10;
	func6(a);//a的值是变量（可读可写），所以会被int& a的函数调用
	func6(10);//常量不可被修改，所以会被const int& a的函数调用,int& a只能引向合法的内存地址

	//func7(a/10),两个都可以传入参数，编译器：我机傻了（滑稽）

	func7(a,10);//参数完整的时候可以运行

	system("pause");
	return 0;
}

#include <iostream>
using namespace std;
	//c++面向对象的三大特性为：封装，继承，多态
	// c++认为万事万物都皆为对象，对象上有其属性和行为,统一称为成员
	//具有相同性质的对象，我们可以抽象称为类
	//属性和行为,统一称为成员
	// 属性	也叫	成员属性 成员变量
	// 行为	也叫	成员函数 成员方法

//圆周率
const double PI = 3.14;

//设计一个圆类，求圆的周长
class Circle 
{
	//访问权限：（公共权限）
	public:
		//属性 （半径）:变量
		int r;
		//行为：（获取圆的周长）：函数
		double ZC()
		{
			return 2 * PI * r;
		}
};

//
//
int main2()
{
	//封装的意义
	// 将属性和行为作为一个整体，表现生活中的事物
	// 将属性和行为加以权限控制
	
	// 将属性和行为作为一个整体，表现生活中的事物
	// 
	//在设计类的时候，属性和行为写在一起，表现事物
	//语法:class 类名{访问权限：属性 / 行为}；

	//通过圆类 创建具体的圆（对象）(实例化)
	Circle c1;
	//给圆的对象 的属性进行赋值
	c1.r = 10;

	cout << "圆的周长为：" << c1.ZC() << endl;


	// 将属性和行为加以权限控制
	// 
	//public	公共权限	成员类内外都可访问
	//protected	保护权限	成员类内可以访问，类外不可访问	在继承中，子可以访问父中的保护内容
	//private	私有权限	成员类内可以访问，类外不可访问	在继承中，子不可以访问父中的私有内容

	system("pause");
	return 0;
}

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


class parson
{
public:
	//公共权限	
	string name;	//姓名

protected:
	//保护权限
	int car_id;		//车的密码

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

public://如果函数不是公共权限，也不可访问
	void func()//在类内，所以权限都可以访问
	{
		name = "张三";
		car_id = 123456;
		password = 123654;
	}
};

int main3()
{

	// 将属性和行为加以权限控制
	// 
	//public	公共权限	成员类内外都可访问
	//protected	保护权限	成员类内可以访问，类外不可访问	在继承中，子可以访问父中的保护内容
	//private	私有权限	成员类内可以访问，类外不可访问	在继承中，子不可以访问父中的私有内容

	parson p1;
	p1.name = "王五";
	//p1.car_id = 123456;不可访问
	//p1.password = 123654;不可访问
	system("pause");
	return 0;
}

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

class C1
{
	int a;//默认权限为私有
};

struct B1
{
	int a;
};

int main0()
{
	//在C++中，struct和class的唯一区别就在于 默认访问权限不同
	//struct	默认权限为公共
	//class		默认权限为私有
	C1 c1;
	//c1.a = 100;默认权限所有不可访问

	B1 b1;
	b1.a = 100;//默认权限公共，可以访问
	system("pause");
	return 0;
}

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

class person
{
public:
	//写入姓名的函数
	void setname(string name1)
	{
		name = name1;
	}

	//读取姓名的函数
	string getname()
	{
		return name;
	}

	//读取年龄的函数
	int getage()
	{
		return age;
	}

	//写入偶像的函数
	void setidol(string idol2)
	{
		idol = idol2;
	}

	//写入年龄（0~150）
	void setage(int age1)
	{
		if (age1 < 0 || age1>150) 
		{
			cout << "输入有误" << endl;
			return;
		}
	}

private:
	string name;//姓名，可读可写

	int age=18;//年龄，只读,可以默认,如果年龄可写，则要限定范围（要检测数据有效性）

	string idol;//偶像，只写

};
int main7()
{
	person p1;
	p1.setname("张三");
	p1.setage(156);
	system("pause");
	ret

#include<iostream>
using namespace std;

//对象的初始化和清理
	//1.构造函数  进行初始化操作
class person
{
public:
	//1.构造函数
	//没有返回值，不用写void
	// 函数名 与类名相同
	// 构造函数可以有参数  可以发生重载
	// 创造对象的时候，构造函数会自动调用，而且只调用一次
	person()
	{
		cout << "person构造函数的调用1111" << endl;

	}

	//2.析构函数 进行清理的操作
	// 没有返回值，不写void
	// 函数名和类名相同，在名称前面加~
	// 没有参数，不可以发生重载
	// 对象在销毁前 会自动调用析构函数，而且只会调用一次
	~person()
	{
		cout << "person析构函数的调用" << endl;

	}


	//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
};

void ABC()
{
	person p1;//在栈区的数据，ABC在执行完之后，释放这个对象
}
	

int main00()
{
	ABC();
	person p2;//在程序结束运行后会执行析构函数

	system("pause");
	return 0;

}

#include<iostream>
using namespace std;

//构造函数的分类和调用
//1.分类
//	按照参数分类	无参构造(默认构造)和有参构造
//	按照类型分类	普通构造	拷贝构造
class person
{
public:
	//构造函数
	person()
	{cout << "person无参构造函数的调用" << endl;}

	person(int a)
	{
		age = a;
		cout << "person有参构造函数的调用" << endl;
	}

	//拷贝构造
	person(const person& p)//如果值传递，则会创建一个副本，将对象的属性复制过来，当 一个对象需要以值方式传递时，编译器会生成代码调用它的拷贝构造函数以生成一个复本。如果类A的拷贝构造函数是以值方式传递一个类A对象作为参数的话，当 需要调用类A的拷贝构造函数时，需要以值方式传进一个A的对象作为实参； 而以值方式传递需要调用类A的拷贝构造函数；结果就是调用类A的拷贝构造函数导 致又一次调用类A的拷贝构造函数，这就是一个无限递归。
	{
		//将传入的人身上的所有属性，拷贝的我（当前对象）身上
		cout << "person拷贝构造函数的调用" << endl;
		age = p.age;
	}

	~person()
	{
		cout << "person析构函数的调用" << endl;}

	
int age;
};
//调用
	void test1()
	{
		// 1.括号法
		person p;//默认构造函数调用
		person p2(10);//有参构造函数调用
		person p3(p2);//拷贝构造函数的调用

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

		//注意：
		// 默认构造函数调用不要加小括号
		// person p ():会被认为是一个声明
		
		// 2.显示法
		person p1;
		person p4 = person(10);
		person p5 = person(p2);

		person(10);//匿名对象   特点：当前行执行结束后，系统会立刻回收匿名对象
		//不要利用拷贝构造函数初始化匿名对象(编译器会认为person（p6）==person p6;对象声明)
		person(p6);
		cout << "aaa" << endl;

		// 3.隐式转化法
		person p7 = 10; //相当于写了person p7=person (10);有参构造
		person p8 = p7;//拷贝构造函数

	}
	
	

int main01()
{
	test1();

	system("pause");
	return 0;

}

#include<iostream>
using namespace std;
//使用时机
// 1.使用一个已经创建完毕的对象来初始化一个新对象
// 2.值传递的方式给函数参数传值
// 3.值的方式返回局部对象

class person1
{
public:
	//构造函数
	person1()
	{
		cout << "person无参构造函数的调用" << endl;
	}

	person1(int a)
	{
		age = a;
		cout << "person有参构造函数的调用" << endl;
	}

	person1(const person1& p)
	{
		age = p.age;
		cout << "person拷贝构造函数的调用" << endl;
	}
	~person1()
	{
		cout << "person析构函数的调用" << endl;
	}


	int age;
};
// 1.使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	person1 p1(20);
	person1 p2(p1);
	cout << "p2的年龄：" << p2.age << endl;
}

// 2.值传递的方式给函数（形参）参数传值(值传递会调用拷贝函数进行创建副本拷贝)
void aaa(person1 a)
{

}
void test02()
{
	person1 p3;
	aaa(p3);//将p3的属性值传递给形参
}

// 3.值的方式返回局部对象
person1 bbb()
{
	person1 p5(20);
	cout << "p5的年龄：" << p5.age << endl;
	cout << (int)&p5;
	 //return p5;不会调用拷贝构造函数，返回本身，所以地址一样
	 return person1 (p5);//会调用拷贝构造函数，返回p4，地址不一样

}
void test03()
{
	person1 p4 = bbb();
	
	cout << "p4的年龄：" << p4.age << endl;
	p4.age = 30;

	cout << (int)&p4;
}

int main004()
{
	
	test03();

	system("pause");
	return 0;

}

#include<iostream>
using namespace std;

//构造函数的调用规则
//1.创建一个类，c++编译器会给每个类都至少添加3个函数
// 默认构造（空实现）
// 析构函数（空实现）
// 拷贝构造 (值拷贝)

// 2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然通过拷贝构造
// 3.如果我们写了拷贝构造函数，编译器就不再提供构造函数
//


class person2
{
public:
	
	/*person2()
	{
		cout << "person构造函数的调用" << endl;

	}*/

	
	/*person2(int a)
	{
		age = a;
		cout << "person有参构造函数的调用" << endl;
	}*/

	person2(const person2& p)
	{
		age = p.age;
		cout << "person拷贝构造函数的调用" << endl;
	}

	~person2()
	{
		cout << "person析构函数的调用" << endl;

	}
	int age;

};

void test001()
{
	/*person2 p;
	p.age = 18;

	person2 p2(p);//默认的值拷贝
	cout << "p2的年龄：" << p2.age << endl;*/

}
void test002()// 2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然通过拷贝构造
{
	//person2 p;
	//person2 p(20);

	//person2 p2(p);//默认的值拷贝
	//cout << "p2的年龄：" << p2.age << endl;

}
int main002()
{
	test001();

	system("pause");
	return 0;

}

#include<iostream>
using namespace std;

//深拷贝和浅拷贝
//浅拷贝的问题就是堆区的重复释放
//深拷贝就是自己写一个拷贝构造函数，拷贝的时候创建一个新的堆区，防止将对象的指针地址拷贝过来


class person3
{
public:

	person3()
	{
		cout << "person构造函数的调用" << endl;

	}


	person3(int age1,int heighit1)
	{
		age = age1;
		height = new int(heighit1);
		cout << "person有参构造函数的调用" << endl;
	}

	~person3()
	{
		//析构代码	将堆区开辟的数据做释放操作
		if (height != NULL)//如果身高的指针不等于空
		{
			delete height;//释放堆区的数据
			height = NULL;//防止野指针的出现

		}
		cout << "person析构函数的调用" << endl;

	}

	person3(const person3& p)
	{
		height = new int(*p.height);//将对象的指针解引用的值放进堆区，并将堆区地址赋给当前的指针
		age = p.age;

	}
	int age;
	int* height;//如果是系统默认的浅拷贝，会把指针地址也拷贝过去，但是当一个类的这个指针被释放之后，再次释放就是非法操作，报错
};

void sest003()
{
	person3 p1(20,160);//栈区规则：先进后出，p1进，p2进，p2出，p1出
	person3 p2(p1);
	cout << "p2的年龄：" << p2.age << endl;
	cout << "p2的身高：" << *p2.height << endl;
}


int main005()
{
	sest003();

	system("pause");
	return 0;

}

#include<iostream>
using namespace std;

//初始化列表初始化属性
//类名(有无参):属性(初始值)，属性(初始值)...{	实现	}

class person4
{
public:
//传统初始化
	/*person4(int a, int b, int c)
	{
		a1 = a;
		b1 = b;
		c1 = c;
	}*/

	//初始化列表初始化属性
	person4() :a1(10), b1(20), c1(30)//是一种无参构造函数
	{
		//实现
	}

	person4(int a, int b, int c) :a1(a), b1(b), c1(c)//有参构造函数
	{

	}
	int a1;
	int b1;
	int c1;

};

void sest005()
{
	person4 p;
	person4 p2(30,20,10);
	cout << p.a1 << endl;
	cout << p.b1 << endl;
	cout << p.c1 << endl;
	cout << p2.a1 << endl;
	cout << p2.b1 << endl;
	cout << p2.c1 << endl;
}

int main006()
{
	sest005();

	system("pause");
	return 0;

}

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

//	类对象作为类成员
//当其他类对象作为本类的成员，在构造的时候先构造其他类对象，再构造自身（先有零件，再有本体）
//析构函数按照栈区规则，先进后出（先析构本体，再析构零件)
class phone
{
public:
	phone(string name)
	{
		name1 = name;
		cout << "手机的构造函数调用" << endl;
	}
	string  name1;
	~phone()
	{
		cout << "手机析构函数的调用" << endl;

	}
};
class person5
{
public:
	person5(string name1, string name2):name(name1),sj(name2)//phone js=name2	隐式转化法phone js =phone(name2)
	{
		cout << "人的构造函数调用" << endl;
		
	}

	~person5()
	{
		cout << "人析构函数的调用" << endl;

	}
	//姓名
	string name;

	// 手机
	phone sj;
	 };

void sest006()
{
	person5 p1("张三", "苹果15");
	cout << p1.name << p1.sj.name1 << endl;

}


int main007()
{
	sest006();

	system("pause");
	return 0;

}

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

//静态成员变量
class phone
{
public:
	// 所以对象都共享同一份数据（相当于末影箱里的物品的数据）
	// 编译阶段就分配了内存
	// 类内声明，类外初始化操作
	//
	static int a;

	//静态成员变量也是有访问权限的
private:
	static int b;
};
int phone::a=100;//类外初始化操作
int phone::b=200;

void sest007()// 所以对象都共享同一份数据（相当于末影箱）
{
	phone p1;
	cout << p1.a << endl;
	phone p2;
	p2.a = 200;
	cout << p1.a << endl;
	cout << p2.a << endl;
}

void sest008()
{
	//静态成员变量 不属于某个对象上，所有对象都共享同一份数据
	//因此静态成员变量有两种访问方式

	//1.通过对象进行访问
	phone p;
	cout << p.a << endl;

	//2.通过类名进行访问
	cout << phone::a << endl;
	//cout << phone::b << endl;错误，没有访问权限
}

int main008()
{
	sest008();

	system("pause");
	return 0;

}

#include<iostream>
using namespace std;
#include <string>
//静态成员函数	（相当于末影箱，只能访问末影箱的数据，不能访问箱子的数据）
// 所以对象共享一个函数
// 静态成员函数只能访问静态成员变量
class phone
{
public:

	static void func()
	{
		c = 300;// 静态成员函数只能访问静态成员变量

		//e=300；静态成员函数不能访问非静态成员变量（因为静态函数是所以对象共享的，如果一个对象调用的时候，函数不知道访问哪个对象的非静态变量）

		cout << "静态函数的调用" << endl;

	}
	
	static int c;
	int e;//非静态成员变量

	//静态成员函数也是有访问权限的
private:
	static int d;
	static void func2()
	{
		cout << "静态函数的调用" << endl;
	}
};
int phone::c = 100;//类外初始化操作
int phone::d = 200;


void sest009()
{
	//访问方法
	//1. 通过对象访问
	phone p1;
	p1.func();
	//p1.func2();报错//静态成员函数也是有访问权限的

	//2. 通过类名访问
	phone::func();
}

int main()
{
	sest009();

	system("pause");
	return 0;

}

#include<iostream>
using namespace std;
//成员变量 和 成员函数 分开储存

class person
{
	int a;//非静态成员变量 属于类的对象上

	static int b;//静态成员变量 不属于类的对象上（只有一份）

	void func(){}//非静态成员函数 不属于类的对象上（只有一份）

	static void func2() {}//静态成员函数 不属于类的对象上（只有一份）
};
int person::b = 10;

void test0()
{
	person p;
	//空对象占用的内存空间为：1
	//C++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置
	//每个空对象也应该有一个独一无二的内存地址
	cout << "空对象的内存多大：" << sizeof(p) << endl;
}

void test1()
{
	person p;
	
	cout << "有int的对象的内存多大：" << sizeof(p) << endl;//
}
int main0()
{
	test1();

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//this指针指向被调用成员函数所属的对象

//1.解决名称冲突

//2.返回对象本身用*this

class person
{
public:
	//1.解决名称冲突
	person(int age)
	{
		this->age = age;//指向 被调用成员函数(person(int age) 所属的对象p1
	}
	int age;

	person& add(person &p)//以引用的方式返回，如果不用引用就是值返回就是拷贝p3本体，实际上返回的是副本person1（如果还返回就是person2，是副本的副本），所以后面的.add（）就和p3没有关系了
	{
		this->age +=p.age;

		return *this;//this指向p3的指针 	*this表示p3的本体
	}
};

//1.解决名称冲突
void test3()
{
	person p1(18);
	cout << "p1的年龄：" << p1.age << endl;
}

//2.返回对象本身用*this
void test2()
{
	person p2(10);
	person p3(20);

	//链式编程思想
	p3.add(p2).add(p2).add(p2);//add函数返回p3的本体，所以可以增加.进行操作
	cout << "p3的年龄：" << p3.age << endl;

}
int main1()
{
	test2();

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//空指针调用成员函数

class person
{
public:
	
	void ShowClassName()
	{
		cout << "这个类的名称叫 person" << endl;
	}

	void  ShowAge()
	{
		//会报错，因为this指针是空指针，解决方法
		if (this == NULL)
		{
			return;
		}
		cout << "这个人的年龄：" << age << endl;//age前面默认有一个this->
	}
	int age;
};


void test4()
{
	person* p = NULL;//空指针

	p->ShowAge();
	p->ShowClassName();

}


void test5()
{
}

int main2()
{
	test4();

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;

//常函数
//在成员函数括号后面加const

//常对象

class person
{
public:
	//常函数
	// 
	//this指针的本质是指针常量，指向不可修改 person * const this
	//this = NULL;是错误的
	//在成员函数后面加const，修饰的是this指针，让指针指向的值也不可修改
	void showage()const//const person * const this
	{
		age1 = 100;
		//this->age = 100;
	}
	int age;
	mutable int age1;//特殊变量，即使在常函数中，也可以修改这个值，在前面加关键字mutable

	void showage2()
	{

	}

};

//常对象
//在对象前加上const
void test6()
{
	const person p;//常对象的正常属性不允许修改
	//p.age = 100;
	p.age1 = 500; //加了mutable的特殊变量在常对象下也可以修改

	//常对象只能调用常函数
	//p.showage2()	因为普通成员函数里面是可以修改属性的值的，所以不能调用普通成员函数

}


void test7()
{
}

int main()
{
	test6();

	system("pause");
	return 0;
}

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

//全局函数做友元

//建筑物类
class buiding
{
	//friend +函数声明 ：全局函数goodgay是buiding类的好朋友，可以访问私有成员
	friend void goodgay(buiding* buiding);
public:
	buiding()
	{
		m_sittingroom = "客厅";
		m_bedroom="卧室";
	}

public:
	string m_sittingroom;//客厅

private:
	string m_bedroom; //卧室
};


//全局函数（好基友）
void goodgay(buiding *buiding)
{
	cout << "好基友的全局函数正在访问：" << buiding->m_sittingroom << endl;
	cout << "好基友的全局函数正在访问：" << buiding->m_bedroom << endl;
}

void test01()
{
	buiding b1;
	goodgay(&b1);

}
int main00()
{
	test01();


	system("pause");
	return 0;
}

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

//类做友元

class buiding;
class goodgay
{
public:
	goodgay();//在堆区开辟一个建筑物对象，用buiding1接收
	void visit();//参观函数通过访问buiding1指针访问在堆区的建筑物对象
	
	buiding * buiding1;

};

//建筑物类
class buiding
{
	//friend +类声明 ：goodgay类是buiding类的好朋友，可以访问私有成员
	friend class goodgay;
public:
	buiding();//将客厅和卧室初始化给下面的变量
	

public:
	string m_sittingroom;//客厅

private:
	string m_bedroom; //卧室
};
//类外写成员函数（注意要类内声明）
buiding::buiding()
{
		m_sittingroom = "客厅";
		m_bedroom = "卧室";
}
goodgay::goodgay()
{
	buiding1 = new buiding;
}
void goodgay::visit()
{
	cout<< "好基友的类正在访问：" <<buiding1->m_sittingroom << endl;
	cout << "好基友的类正在访问：" << buiding1->m_bedroom << endl;
};

void test02()
{
	goodgay gg;
	gg.visit();
	

}
int main()
{
	test02();


	system("pause");
	return 0;
}