C++基础查漏补缺

 1//1、宏常量
 2#define day 7
 3
 4int main() {
 5
 6	cout << "一周里总共有 " << day << " 天" << endl;
 7	//day = 8;  //报错，宏常量不可以修改
 8
 9	//2、const修饰变量
10	const int month = 12;
11	cout << "一年里总共有 " << month << " 个月份" << endl;
12	//month = 24; //报错，常量是不可以修改的
13	
14	
15	system("pause");
16
17	return 0;
18}

 1switch(表达式)
 2
 3{
 4
 5	case 结果1：执行语句;break;
 6
 7	case 结果2：执行语句;break;
 8
 9	...
10
11	default:执行语句;break;
12
13}
14

 1int main() {
 2
 3	//请给电影评分 
 4	//10 ~ 9   经典   
 5	// 8 ~ 7   非常好
 6	// 6 ~ 5   一般
 7	// 5分以下 烂片
 8
 9	int score = 0;
10	cout << "请给电影打分" << endl;
11	cin >> score;
12
13	switch (score)
14	{
15	case 10:
16	case 9:
17		cout << "经典" << endl;
18		break;
19	case 8:
20		cout << "非常好" << endl;
21		break;
22	case 7:
23	case 6:
24		cout << "一般" << endl;
25		break;
26	default:
27		cout << "烂片" << endl;
28		break;
29	}
30
31	system("pause");
32
33	return 0;
34}

 1int main() {
 2
 3	cout << "1" << endl;
 4
 5	goto FLAG;
 6
 7	cout << "2" << endl;
 8	cout << "3" << endl;
 9	cout << "4" << endl;
10
11	FLAG:
12
13	cout << "5" << endl;
14	
15	system("pause");
16
17	return 0;
18}

 1int main() {
 2
 3	//数组名用途
 4	//1、可以获取整个数组占用内存空间大小
 5	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 6
 7	cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
 8	cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
 9	cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;
10
11	//2、可以通过数组名获取到数组首地址
12	cout << "数组首地址为： " << (int)arr << endl;
13	cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
14	cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;
15
16	//arr = 100; 错误，数组名是常量，因此不可以赋值
17
18
19	system("pause");
20
21	return 0;
22}

 1int main() {
 2
 3	//二维数组数组名
 4	int arr[2][3] =
 5	{
 6		{1,2,3},
 7		{4,5,6}
 8	};
 9
10	cout << "二维数组大小： " << sizeof(arr) << endl;
11	cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
12	cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;
13
14	cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
15	cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
16
17	//地址
18	cout << "二维数组首地址：" << arr << endl;
19	cout << "二维数组第一行地址：" << arr[0] << endl;
20	cout << "二维数组第二行地址：" << arr[1] << endl;
21
22	cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
23	cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;
24
25	system("pause");
26
27	return 0;
28}

1返回值类型 函数名 （参数列表）
2{
3
4       函数体语句
5
6       return表达式
7
8}

1//swap.h文件
2#include<iostream>
3using namespace std;
4
5//实现两个数字交换的函数声明
6void swap(int a, int b);
7

 1//swap.cpp文件
 2#include "swap.h"
 3
 4void swap(int a, int b)
 5{
 6	int temp = a;
 7	a = b;
 8	b = temp;
 9
10	cout << "a = " << a << endl;
11	cout << "b = " << b << endl;
12}

 1//main函数文件
 2#include "swap.h"
 3int main() {
 4
 5	int a = 100;
 6	int b = 200;
 7	swap(a, b);
 8
 9	system("pause");
10
11	return 0;
12}
13

 1int main() {
 2
 3	//1、指针的定义
 4	int a = 10; //定义整型变量a
 5	
 6	//指针定义语法： 数据类型 * 变量名 ;
 7	int * p;
 8
 9	//指针变量赋值
10	p = &a; //指针指向变量a的地址
11	cout << &a << endl; //打印数据a的地址
12	cout << p << endl;  //打印指针变量p
13
14	//2、指针的使用
15	//通过*操作指针变量指向的内存
16	cout << "*p = " << *p << endl;
17
18	system("pause");
19
20	return 0;
21}

 1int main() {
 2
 3	//指针变量p指向内存地址编号为0的空间
 4	int * p = NULL;
 5
 6	//访问空指针报错 
 7	//内存编号0 ~255为系统占用内存，不允许用户访问
 8	cout << *p << endl;
 9
10	system("pause");
11
12	return 0;
13}

 1int main() {
 2
 3	//指针变量p指向内存地址编号为0x1100的空间
 4	int * p = (int *)0x1100;
 5
 6	//访问野指针报错 
 7	cout << *p << endl;
 8
 9	system("pause");
10
11	return 0;
12}

 1int main() {
 2
 3	int a = 10;
 4	int b = 10;
 5
 6	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
 7	const int * p1 = &a; 
 8	p1 = &b; //正确
 9	//*p1 = 100;  报错
10	
11
12	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
13	int * const p2 = &a;
14	//p2 = &b; //错误
15	*p2 = 100; //正确
16
17    //const既修饰指针又修饰常量
18	const int * const p3 = &a;
19	//p3 = &b; //错误
20	//*p3 = 100; //错误
21
22	system("pause");
23
24	return 0;
25}

 1int main() {
 2
 3	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
 4
 5	int * p = arr;  //指向数组的指针
 6
 7	cout << "第一个元素： " << arr[0] << endl;
 8	cout << "指针访问第一个元素： " << *p << endl;
 9
10	for (int i = 0; i < 10; i++)
11	{
12		//利用指针遍历数组
13		cout << *p << endl;
14		p++;
15	}
16
17	system("pause");
18
19	return 0;
20}

1//地址传递
2void swap2(int * p1, int *p2)
3{
4	int temp = *p1;
5	*p1 = *p2;
6	*p2 = temp;
7}

 1//结构体定义
 2struct student
 3{
 4	//成员列表
 5	string name;  //姓名
 6	int age;      //年龄
 7	int score;    //分数
 8}stu3; //结构体变量创建方式3 
 9
10
11int main() {
12
13	//结构体变量创建方式1
14	struct student stu1; //struct 关键字可以省略
15
16	stu1.name = "张三";
17	stu1.age = 18;
18	stu1.score = 100;
19	
20	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;
21
22	//结构体变量创建方式2
23	struct student stu2 = { "李四",19,60 };
24
25	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;
26
27
28	stu3.name = "王五";
29	stu3.age = 18;
30	stu3.score = 80;
31	
32
33	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;
34
35	system("pause");
36
37	return 0;
38}

1struct student arr[3]=
2	{
3		{"张三",18,80 },
4		{"李四",19,60 },
5		{"王五",20,70 }
6	};
7

 1int main() {
 2	
 3	struct student stu = { "张三",18,100, };
 4	
 5	struct student * p = &stu;
 6	
 7	p->score = 80; //指针通过 -> 操作符可以访问成员
 8
 9	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
10	
11	system("pause");
12
13	return 0;
14}

 1//值传递
 2void printStudent(student stu )
 3{
 4	stu.age = 28;
 5	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
 6}
 7
 8//地址传递
 9void printStudent2(student *stu)
10{
11	stu->age = 28;
12	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
13}

1//const使用场景
2void printStudent(const student *stu) //加const防止函数体中的误操作
3{
4	//stu->age = 100; //操作失败，因为加了const修饰
5	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;
6
7}

 1int* func()
 2{
 3	int* a = new int(10);
 4	return a;
 5}
 6
 7int main() {
 8
 9	int *p = func();
10
11	cout << *p << endl;
12	cout << *p << endl;
13
14	//利用delete释放堆区数据
15	delete p;
16
17	//cout << *p << endl; //报错，释放的空间不可访问
18
19	system("pause");
20
21	return 0;
22}

 1//堆区开辟数组
 2int main() {
 3
 4	int* arr = new int[10];
 5
 6	for (int i = 0; i < 10; i++)
 7	{
 8		arr[i] = i + 100;
 9	}
10
11	for (int i = 0; i < 10; i++)
12	{
13		cout << arr[i] << endl;
14	}
15	//释放数组 delete 后加 []
16	delete[] arr;
17
18	system("pause");
19
20	return 0;
21}
22

 1int main() {
 2
 3	int a = 10;
 4	int b = 20;
 5	//int &c; //错误，引用必须初始化
 6	int &c = a; //一旦初始化后，就不可以更改
 7	c = b; //这是赋值操作，不是更改引用
 8
 9	cout << "a = " << a << endl;
10	cout << "b = " << b << endl;
11	cout << "c = " << c << endl;
12
13	system("pause");
14
15	return 0;
16}

 1//1. 值传递
 2void mySwap01(int a, int b) {
 3	int temp = a;
 4	a = b;
 5	b = temp;
 6}
 7
 8//2. 地址传递
 9void mySwap02(int* a, int* b) {
10	int temp = *a;
11	*a = *b;
12	*b = temp;
13}
14
15//3. 引用传递
16void mySwap03(int& a, int& b) {
17	int temp = a;
18	a = b;
19	b = temp;
20}

 1//返回局部变量引用
 2int& test01() {
 3	int a = 10; //局部变量
 4	return a;
 5}
 6
 7//返回静态变量引用
 8int& test02() {
 9	static int a = 20;
10	return a;
11}
12
13int main() {
14
15	//不能返回局部变量的引用
16	int& ref = test01();
17	cout << "ref = " << ref << endl;
18	cout << "ref = " << ref << endl;
19
20	//如果函数做左值，那么必须返回引用
21	int& ref2 = test02();
22	cout << "ref2 = " << ref2 << endl;
23	cout << "ref2 = " << ref2 << endl;
24
25	test02() = 1000;
26
27	cout << "ref2 = " << ref2 << endl;
28	cout << "ref2 = " << ref2 << endl;
29
30	system("pause");
31
32	return 0;
33}

 1//发现是引用，转换为 int* const ref = &a;
 2void func(int& ref){
 3	ref = 100; // ref是引用，转换为*ref = 100
 4}
 5int main(){
 6	int a = 10;
 7    
 8    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
 9	int& ref = a; 
10	ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
11    
12	cout << "a:" << a << endl;
13	cout << "ref:" << ref << endl;
14    
15	func(a);
16	return 0;
17}

 1//引用使用的场景，通常用来修饰形参
 2void showValue(const int& v) {
 3	//v += 10;
 4	cout << v << endl;
 5}
 6
 7int main() {
 8
 9	//int& ref = 10;  引用本身需要一个合法的内存空间，因此这行错误
10	//加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
11	const int& ref = 10;
12
13	//ref = 100;  //加入const后不可以修改变量
14	cout << ref << endl;
15
16	//函数中利用常量引用防止误操作修改实参
17	int a = 10;
18	showValue(a);
19
20	system("pause");
21
22	return 0;
23}

 1int func(int a, int b = 10, int c = 10) {
 2	return a + b + c;
 3}
 4
 5//1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
 6//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数
 7int func2(int a = 10, int b = 10);
 8int func2(int a, int b) {
 9	return a + b;
10}

 1//函数占位参数 ，占位参数也可以有默认参数
 2void func(int a, int) {
 3	cout << "this is func" << endl;
 4}
 5
 6int main() {
 7
 8	func(10,10); //占位参数必须填补
 9
10	system("pause");
11
12	return 0;
13}

 1//函数重载注意事项
 2//1、引用作为重载条件
 3
 4void func(int &a)
 5{
 6	cout << "func (int &a) 调用 " << endl;
 7}
 8
 9void func(const int &a)
10{
11	cout << "func (const int &a) 调用 " << endl;
12}
13
14
15//2、函数重载碰到函数默认参数
16
17void func2(int a, int b = 10)
18{
19	cout << "func2(int a, int b = 10) 调用" << endl;
20}
21
22void func2(int a)
23{
24	cout << "func2(int a) 调用" << endl;
25}
26
27int main() {
28	
29	int a = 10;
30	func(a); //调用无const
31	func(10);//调用有const
32
33
34	//func2(10); //碰到默认参数产生歧义，需要避免
35
36	system("pause");
37
38	return 0;
39}

 1//三种权限
 2//公共权限  public     类内可以访问  类外可以访问
 3//保护权限  protected  类内可以访问  类外不可以访问
 4//私有权限  private    类内可以访问  类外不可以访问
 5
 6class Person
 7{
 8	//姓名  公共权限
 9public:
10	string m_Name;
11
12	//汽车  保护权限
13protected:
14	string m_Car;
15
16	//银行卡密码  私有权限
17private:
18	int m_Password;
19
20public:
21	void func()
22	{
23		m_Name = "张三";
24		m_Car = "拖拉机";
25		m_Password = 123456;
26	}
27};
28
29int main() {
30
31	Person p;
32	p.m_Name = "李四";
33	//p.m_Car = "奔驰";  //保护权限类外访问不到
34	//p.m_Password = 123; //私有权限类外访问不到
35
36	system("pause");
37
38	return 0;
39}

 1class C1
 2{
 3	int  m_A; //默认是私有权限
 4};
 5
 6struct C2
 7{
 8	int m_A;  //默认是公共权限
 9};
10
11int main() {
12
13	C1 c1;
14	c1.m_A = 10; //错误，访问权限是私有
15
16	C2 c2;
17	c2.m_A = 10; //正确，访问权限是公共
18
19	system("pause");
20
21	return 0;
22}

 1class Person {
 2public:
 3	//无参（默认）构造函数
 4	Person() {
 5		cout << "无参构造函数!" << endl;
 6	}
 7	//有参构造函数
 8	Person(int a) {
 9		age = a;
10		cout << "有参构造函数!" << endl;
11	}
12	//拷贝构造函数
13	Person(const Person& p) {
14		age = p.age;
15		cout << "拷贝构造函数!" << endl;
16	}
17	//析构函数
18	~Person() {
19		cout << "析构函数!" << endl;
20	}
21public:
22	int age;
23};
24
25//2、构造函数的调用
26//调用无参构造函数
27void test01() {
28	Person p; //调用无参构造函数
29}
30
31//调用有参的构造函数
32void test02() {
33
34	//2.1  括号法，常用
35	Person p1(10);
36	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
37	//Person p2();
38
39	//2.2 显式法
40	Person p2 = Person(10); 
41	Person p3 = Person(p2);
42	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构
43
44	//2.3 隐式转换法
45	Person p4 = 10; // Person p4 = Person(10); 
46	Person p5 = p4; // Person p5 = Person(p4); 
47
48	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
49	//Person p5(p4);
50}
51
52int main() {
53
54	test01();
55	//test02();
56
57	system("pause");
58
59	return 0;
60}

 1class Person {
 2public:
 3	Person() {
 4		cout << "无参构造函数!" << endl;
 5		mAge = 0;
 6	}
 7	Person(int age) {
 8		cout << "有参构造函数!" << endl;
 9		mAge = age;
10	}
11	Person(const Person& p) {
12		cout << "拷贝构造函数!" << endl;
13		mAge = p.mAge;
14	}
15	//析构函数在释放内存之前调用
16	~Person() {
17		cout << "析构函数!" << endl;
18	}
19public:
20	int mAge;
21};
22
23//1. 使用一个已经创建完毕的对象来初始化一个新对象
24void test01() {
25
26	Person man(100); //p对象已经创建完毕
27	Person newman(man); //调用拷贝构造函数
28	Person newman2 = man; //拷贝构造
29
30	//Person newman3;
31	//newman3 = man; //不是调用拷贝构造函数，赋值操作
32}
33
34//2. 值传递的方式给函数参数传值
35//相当于Person p1 = p;
36void doWork(Person p1) {}
37void test02() {
38	Person p; //无参构造函数
39	doWork(p);
40}
41
42//3. 以值方式返回局部对象
43Person doWork2()
44{
45	Person p1;
46	cout << (int *)&p1 << endl;
47	return p1;
48}
49
50void test03()
51{
52	Person p = doWork2();
53	cout << (int *)&p << endl;
54}
55
56
57int main() {
58
59	//test01();
60	//test02();
61	test03();
62
63	system("pause");
64
65	return 0;
66}

 1class Person {
 2public:
 3	//无参（默认）构造函数
 4	Person() {
 5		cout << "无参构造函数!" << endl;
 6	}
 7	//有参构造函数
 8	Person(int a) {
 9		age = a;
10		cout << "有参构造函数!" << endl;
11	}
12	//拷贝构造函数
13	Person(const Person& p) {
14		age = p.age;
15		cout << "拷贝构造函数!" << endl;
16	}
17	//析构函数
18	~Person() {
19		cout << "析构函数!" << endl;
20	}
21public:
22	int age;
23};
24
25void test01()
26{
27	Person p1(18);
28	//如果不写拷贝构造，编译器会自动添加拷贝构造，并且做浅拷贝操作
29	Person p2(p1);
30
31	cout << "p2的年龄为： " << p2.age << endl;
32}
33
34void test02()
35{
36	//如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
37	Person p1; //此时如果用户自己没有提供默认构造，会出错
38	Person p2(10); //用户提供的有参
39	Person p3(p2); //此时如果用户没有提供拷贝构造，编译器会提供
40
41	//如果用户提供拷贝构造，编译器不会提供其他构造函数
42	Person p4; //此时如果用户自己没有提供默认构造，会出错
43	Person p5(10); //此时如果用户自己没有提供有参，会出错
44	Person p6(p5); //用户自己提供拷贝构造
45}
46
47int main() {
48
49	test01();
50
51	system("pause");
52
53	return 0;
54}

 1class Person {
 2public:
 3	//无参（默认）构造函数
 4	Person() {
 5		cout << "无参构造函数!" << endl;
 6	}
 7	//有参构造函数
 8	Person(int age ,int height) {
 9		
10		cout << "有参构造函数!" << endl;
11
12		m_age = age;
13		m_height = new int(height);
14		
15	}
16	//拷贝构造函数  
17	Person(const Person& p) {
18		cout << "拷贝构造函数!" << endl;
19		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
20		m_age = p.m_age;
21		m_height = new int(*p.m_height);
22		
23	}
24
25	//析构函数
26	~Person() {
27		cout << "析构函数!" << endl;
28		if (m_height != NULL)
29		{
30			delete m_height;
31		}
32	}
33public:
34	int m_age;
35	int* m_height;
36};

1	////传统方式初始化
2	//Person(int a, int b, int c) {
3	//	m_A = a;
4	//	m_B = b;
5	//	m_C = c;
6	//}
7
8	//初始化列表方式初始化
9	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}

 1class Person {
 2public:
 3	Person() {
 4		mA = 0;
 5	}
 6	//非静态成员变量占对象空间
 7	int mA;
 8	//静态成员变量不占对象空间
 9	static int mB; 
10	//函数也不占对象空间，所有函数共享一个函数实例
11	void func() {
12		cout << "mA:" << this->mA << endl;
13	}
14	//静态成员函数也不占对象空间
15	static void sfunc() {
16	}
17};

 1Person(int age)
 2	{
 3		//1、当形参和成员变量同名时，可用this指针来区分
 4		this->age = age;
 5	}
 6
 7	Person& PersonAddPerson(Person p)
 8	{
 9		this->age += p.age;
10		//返回对象本身
11		return *this;
12	}

 1//空指针访问成员函数
 2class Person {
 3public:
 4
 5	void ShowClassName() {
 6		cout << "我是Person类!" << endl;
 7	}
 8
 9	void ShowPerson() {
10		if (this == NULL) {
11			return;
12		}
13		cout << mAge << endl;
14	}
15
16public:
17	int mAge;
18};
19
20void test01()
21{
22	Person * p = NULL;
23	p->ShowClassName(); //空指针，可以调用成员函数
24	p->ShowPerson();  //但是如果成员函数中用到了this指针，就不可以了
25}

 1class Person {
 2public:
 3	Person() {
 4		m_A = 0;
 5		m_B = 0;
 6	}
 7
 8	//this指针的本质是一个指针常量，指针的指向不可修改
 9	//如果想让指针指向的值也不可以修改，需要声明常函数
10	void ShowPerson() const {
11		//const Type* const pointer;
12		//this = NULL; //不能修改指针的指向 Person* const this;
13		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的
14
15		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
16		this->m_B = 100;
17	}
18
19	void MyFunc() const {
20		//mA = 10000;
21	}
22
23public:
24	int m_A;
25	mutable int m_B; //可修改 可变的
26};
27
28
29//const修饰对象  常对象
30void test01() {
31
32	const Person person; //常量对象  
33	cout << person.m_A << endl;
34	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
35	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
36
37	//常对象访问成员函数
38	person.MyFunc(); //常对象不能调用const的函数
39
40}

 1class Building
 2{
 3	//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
 4	friend void goodGay(Building * building);
 5
 6public:
 7
 8	Building()
 9	{
10		this->m_SittingRoom = "客厅";
11		this->m_BedRoom = "卧室";
12	}
13
14
15public:
16	string m_SittingRoom; //客厅
17
18private:
19	string m_BedRoom; //卧室
20};
21
22
23void goodGay(Building * building)
24{
25	cout << "好基友正在访问： " << building->m_SittingRoom << endl;
26	cout << "好基友正在访问： " << building->m_BedRoom << endl;
27}
28
29
30void test01()
31{
32	Building b;
33	goodGay(&b);
34}
35

 1class Building;
 2class goodGay
 3{
 4public:
 5
 6	goodGay();
 7	void visit();
 8
 9private:
10	Building *building;
11};
12
13
14class Building
15{
16	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
17	friend class goodGay;
18
19public:
20	Building();
21
22public:
23	string m_SittingRoom; //客厅
24private:
25	string m_BedRoom;//卧室
26};
27
28Building::Building()
29{
30	this->m_SittingRoom = "客厅";
31	this->m_BedRoom = "卧室";
32}
33
34goodGay::goodGay()
35{
36	building = new Building;
37}
38
39void goodGay::visit()
40{
41	cout << "好基友正在访问" << building->m_SittingRoom << endl;
42	cout << "好基友正在访问" << building->m_BedRoom << endl;
43}
44
45void test01()
46{
47	goodGay gg;
48	gg.visit();
49
50}

 1class Building;
 2class goodGay
 3{
 4public:
 5
 6	goodGay();
 7	void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
 8	void visit2(); 
 9
10private:
11	Building *building;
12};
13
14
15class Building
16{
17	//告诉编译器  goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
18	friend void goodGay::visit();
19
20public:
21	Building();
22
23public:
24	string m_SittingRoom; //客厅
25private:
26	string m_BedRoom;//卧室
27};
28
29Building::Building()
30{
31	this->m_SittingRoom = "客厅";
32	this->m_BedRoom = "卧室";
33}
34
35goodGay::goodGay()
36{
37	building = new Building;
38}
39
40void goodGay::visit()
41{
42	cout << "好基友正在访问" << building->m_SittingRoom << endl;
43	cout << "好基友正在访问" << building->m_BedRoom << endl;
44}
45
46void goodGay::visit2()
47{
48	cout << "好基友正在访问" << building->m_SittingRoom << endl;
49	//cout << "好基友正在访问" << building->m_BedRoom << endl;
50}
51
52void test01()
53{
54	goodGay  gg;
55	gg.visit();
56
57}

 1class Person {
 2public:
 3	Person() {};
 4	Person(int a, int b)
 5	{
 6		this->m_A = a;
 7		this->m_B = b;
 8	}
 9	//成员函数实现 + 号运算符重载
10	Person operator+(const Person& p) {
11		Person temp;
12		temp.m_A = this->m_A + p.m_A;
13		temp.m_B = this->m_B + p.m_B;
14		return temp;
15	}
16
17
18public:
19	int m_A;
20	int m_B;
21};
22
23//全局函数实现 + 号运算符重载
24//Person operator+(const Person& p1, const Person& p2) {
25//	Person temp(0, 0);
26//	temp.m_A = p1.m_A + p2.m_A;
27//	temp.m_B = p1.m_B + p2.m_B;
28//	return temp;
29//}
30
31//运算符重载 可以发生函数重载 
32Person operator+(const Person& p2, int val)  
33{
34	Person temp;
35	temp.m_A = p2.m_A + val;
36	temp.m_B = p2.m_B + val;
37	return temp;
38}
39
40void test() {
41
42	Person p1(10, 10);
43	Person p2(20, 20);
44
45	//成员函数方式
46	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
47	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
48
49
50	Person p4 = p3 + 10; //相当于 operator+(p3,10)
51	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
52
53}

 1class Person {
 2	friend ostream& operator<<(ostream& out, Person& p);
 3
 4public:
 5
 6	Person(int a, int b)
 7	{
 8		this->m_A = a;
 9		this->m_B = b;
10	}
11
12	//成员函数 实现不了  p << cout 不是我们想要的效果
13	//void operator<<(Person& p){
14	//}
15
16private:
17	int m_A;
18	int m_B;
19};
20
21//全局函数实现左移重载
22//ostream对象只能有一个
23ostream& operator<<(ostream& out, Person& p) {
24	out << "a:" << p.m_A << " b:" << p.m_B;
25	return out;
26}
27
28void test() {
29
30	Person p1(10, 20);
31
32	cout << p1 << "hello world" << endl; //链式编程
33}
34

 1class MyInteger {
 2
 3	friend ostream& operator<<(ostream& out, MyInteger myint);
 4
 5public:
 6	MyInteger() {
 7		m_Num = 0;
 8	}
 9	//前置++
10	MyInteger& operator++() {
11		//先++
12		m_Num++;
13		//再返回
14		return *this;
15	}
16
17	//后置++
18	MyInteger operator++(int) {
19		//先返回
20		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
21		m_Num++;
22		return temp;
23	}
24
25private:
26	int m_Num;
27};
28
29
30ostream& operator<<(ostream& out, MyInteger myint) {
31	out << myint.m_Num;
32	return out;
33}
34
35
36//前置++ 先++ 再返回
37void test01() {
38	MyInteger myInt;
39	cout << ++myInt << endl;
40	cout << myInt << endl;
41}
42
43//后置++ 先返回 再++
44void test02() {
45
46	MyInteger myInt;
47	cout << myInt++ << endl;
48	cout << myInt << endl;
49}

 1class Person
 2{
 3public:
 4
 5	Person(int age)
 6	{
 7		//将年龄数据开辟到堆区
 8		m_Age = new int(age);
 9	}
10
11	//重载赋值运算符 
12	Person& operator=(Person &p)
13	{
14		if (m_Age != NULL)
15		{
16			delete m_Age;
17			m_Age = NULL;
18		}
19		//编译器提供的代码是浅拷贝
20		//m_Age = p.m_Age;
21
22		//提供深拷贝 解决浅拷贝的问题
23		m_Age = new int(*p.m_Age);
24
25		//返回自身
26		return *this;
27	}
28
29
30	~Person()
31	{
32		if (m_Age != NULL)
33		{
34			delete m_Age;
35			m_Age = NULL;
36		}
37	}
38
39	//年龄的指针
40	int *m_Age;
41
42};
43
44
45void test01()
46{
47	Person p1(18);
48
49	Person p2(20);
50
51	Person p3(30);
52
53	p3 = p2 = p1; //赋值操作
54
55	cout << "p1的年龄为：" << *p1.m_Age << endl;
56
57	cout << "p2的年龄为：" << *p2.m_Age << endl;
58
59	cout << "p3的年龄为：" << *p3.m_Age << endl;
60}

 1class Person
 2{
 3public:
 4	Person(string name, int age)
 5	{
 6		this->m_Name = name;
 7		this->m_Age = age;
 8	};
 9
10	bool operator==(Person & p)
11	{
12		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
13		{
14			return true;
15		}
16		else
17		{
18			return false;
19		}
20	}
21
22	bool operator!=(Person & p)
23	{
24		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
25		{
26			return false;
27		}
28		else
29		{
30			return true;
31		}
32	}
33
34	string m_Name;
35	int m_Age;
36};

 1class MyPrint
 2{
 3public:
 4	void operator()(string text)
 5	{
 6		cout << text << endl;
 7	}
 8
 9};
10void test01()
11{
12	//重载的（）操作符 也称为仿函数
13	MyPrint myFunc;
14	myFunc("hello world");
15}
16
17
18class MyAdd
19{
20public:
21	int operator()(int v1, int v2)
22	{
23		return v1 + v2;
24	}
25};
26
27void test02()
28{
29	MyAdd add;
30	int ret = add(10, 10);
31	cout << "ret = " << ret << endl;
32
33	//匿名对象调用  
34	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
35}

 1class Base1
 2{
 3public: 
 4	int m_A;
 5protected:
 6	int m_B;
 7private:
 8	int m_C;
 9};
10
11//公共继承
12class Son1 :public Base1
13{
14public:
15	void func()
16	{
17		m_A; //可访问 public权限
18		m_B; //可访问 protected权限
19		//m_C; //不可访问
20	}
21};
22
23void myClass()
24{
25	Son1 s1;
26	s1.m_A; //其他类只能访问到公共权限
27}
28
29//保护继承
30class Base2
31{
32public:
33	int m_A;
34protected:
35	int m_B;
36private:
37	int m_C;
38};
39class Son2:protected Base2
40{
41public:
42	void func()
43	{
44		m_A; //可访问 protected权限
45		m_B; //可访问 protected权限
46		//m_C; //不可访问
47	}
48};
49void myClass2()
50{
51	Son2 s;
52	//s.m_A; //不可访问
53}
54
55//私有继承
56class Base3
57{
58public:
59	int m_A;
60protected:
61	int m_B;
62private:
63	int m_C;
64};
65class Son3:private Base3
66{
67public:
68	void func()
69	{
70		m_A; //可访问 private权限
71		m_B; //可访问 private权限
72		//m_C; //不可访问
73	}
74};
75class GrandSon3 :public Son3
76{
77public:
78	void func()
79	{
80		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
81		//m_A;
82		//m_B;
83		//m_C;
84	}
85};

 1class Base {
 2public:
 3	Base()
 4	{
 5		m_A = 100;
 6	}
 7
 8	void func()
 9	{
10		cout << "Base - func()调用" << endl;
11	}
12
13	void func(int a)
14	{
15		cout << "Base - func(int a)调用" << endl;
16	}
17
18public:
19	int m_A;
20};
21
22
23class Son : public Base {
24public:
25	Son()
26	{
27		m_A = 200;
28	}
29
30	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
31	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
32	void func()
33	{
34		cout << "Son - func()调用" << endl;
35	}
36public:
37	int m_A;
38};
39
40void test01()
41{
42	Son s;
43
44	cout << "Son下的m_A = " << s.m_A << endl;
45	cout << "Base下的m_A = " << s.Base::m_A << endl;
46
47	s.func();
48	s.Base::func();
49	s.Base::func(10);
50
51}

 1class Base {
 2public:
 3	static void func()
 4	{
 5		cout << "Base - static void func()" << endl;
 6	}
 7	static void func(int a)
 8	{
 9		cout << "Base - static void func(int a)" << endl;
10	}
11
12	static int m_A;
13};
14
15int Base::m_A = 100;
16
17class Son : public Base {
18public:
19	static void func()
20	{
21		cout << "Son - static void func()" << endl;
22	}
23	static int m_A;
24};
25
26int Son::m_A = 200;
27
28//同名成员属性
29void test01()
30{
31	//通过对象访问
32	cout << "通过对象访问： " << endl;
33	Son s;
34	cout << "Son  下 m_A = " << s.m_A << endl;
35	cout << "Base 下 m_A = " << s.Base::m_A << endl;
36
37	//通过类名访问
38	cout << "通过类名访问： " << endl;
39	cout << "Son  下 m_A = " << Son::m_A << endl;
40	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
41}
42
43//同名成员函数
44void test02()
45{
46	//通过对象访问
47	cout << "通过对象访问： " << endl;
48	Son s;
49	s.func();
50	s.Base::func();
51
52	cout << "通过类名访问： " << endl;
53	Son::func();
54	Son::Base::func();
55	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
56	Son::Base::func(100);
57}

 1class Base1 {
 2public:
 3	Base1()
 4	{
 5		m_A = 100;
 6	}
 7public:
 8	int m_A;
 9};
10
11class Base2 {
12public:
13	Base2()
14	{
15		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
16	}
17public:
18	int m_A;
19};
20
21//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
22class Son : public Base2, public Base1 
23{
24public:
25	Son()
26	{
27		m_C = 300;
28		m_D = 400;
29	}
30public:
31	int m_C;
32	int m_D;
33};
34
35
36//多继承容易产生成员同名的情况
37//通过使用类名作用域可以区分调用哪一个基类的成员
38void test01()
39{
40	Son s;
41	cout << "sizeof Son = " << sizeof(s) << endl;
42	cout << s.Base1::m_A << endl;
43	cout << s.Base2::m_A << endl;
44}

 1class Animal
 2{
 3public:
 4	int m_Age;
 5};
 6
 7//继承前加virtual关键字后，变为虚继承
 8//此时公共的父类Animal称为虚基类
 9class Sheep : virtual public Animal {};
10class Tuo   : virtual public Animal {};
11class SheepTuo : public Sheep, public Tuo {};
12
13void test01()
14{
15	SheepTuo st;
16	st.Sheep::m_Age = 100;
17	st.Tuo::m_Age = 200;
18
19	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
20	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
21	cout << "st.m_Age = " << st.m_Age << endl;
22}

 1class Animal
 2{
 3public:
 4	//Speak函数就是虚函数
 5	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
 6	virtual void speak()
 7	{
 8		cout << "动物在说话" << endl;
 9	}
10};
11
12class Cat :public Animal
13{
14public:
15	void speak()
16	{
17		cout << "小猫在说话" << endl;
18	}
19};
20
21class Dog :public Animal
22{
23public:
24
25	void speak()
26	{
27		cout << "小狗在说话" << endl;
28	}
29
30};
31//我们希望传入什么对象，那么就调用什么对象的函数
32//如果函数地址在编译阶段就能确定，那么静态联编
33//如果函数地址在运行阶段才能确定，就是动态联编
34
35void DoSpeak(Animal & animal)
36{
37	animal.speak();
38}
39//
40//多态满足条件： 
41//1、有继承关系
42//2、子类重写父类中的虚函数
43//多态使用：
44//父类指针或引用指向子类对象
45
46void test01()
47{
48	Cat cat;
49	DoSpeak(cat);
50
51
52	Dog dog;
53	DoSpeak(dog);
54}

 1//多态实现
 2//抽象计算器类
 3//多态优点：代码组织结构清晰，可读性强，利于前期和后期的扩展以及维护
 4class AbstractCalculator
 5{
 6public :
 7
 8	virtual int getResult()
 9	{
10		return 0;
11	}
12
13	int m_Num1;
14	int m_Num2;
15};
16
17//加法计算器
18class AddCalculator :public AbstractCalculator
19{
20public:
21	int getResult()
22	{
23		return m_Num1 + m_Num2;
24	}
25};
26
27//减法计算器
28class SubCalculator :public AbstractCalculator
29{
30public:
31	int getResult()
32	{
33		return m_Num1 - m_Num2;
34	}
35};
36
37//乘法计算器
38class MulCalculator :public AbstractCalculator
39{
40public:
41	int getResult()
42	{
43		return m_Num1 * m_Num2;
44	}
45};
46
47
48void test02()
49{
50	//创建加法计算器
51	AbstractCalculator *abc = new AddCalculator;
52	abc->m_Num1 = 10;
53	abc->m_Num2 = 10;
54	cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
55	delete abc;  //用完了记得销毁
56
57	//创建减法计算器
58	abc = new SubCalculator;
59	abc->m_Num1 = 10;
60	abc->m_Num2 = 10;
61	cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;
62	delete abc;  
63
64	//创建乘法计算器
65	abc = new MulCalculator;
66	abc->m_Num1 = 10;
67	abc->m_Num2 = 10;
68	cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;
69	delete abc;
70}
71