C++第二阶段-类

A.对象特性

一、类的定义

封装：属性与行为作为一个整体
     将属性和行为加以权限控制
类和对象
class 类名{
    //访问权限三种：1、公共权限public    成员 类内可以访问   类外可以访问
               2、保护权限protected 成员 类内可以访问   类外不可以访问  
               3、私有权限private   成员 类内可以访问   类外不可以访问
            （学习到继承的时候会看到保护权限和私有权限的区别：
              儿子可以访问父亲中的保护内容
                   儿子不可以访问父亲中的私有内容）
    //公共权限
    public：
        属性（半径）
        int m；
        行为（获取圆的周长）
        double

    //保护权限
    protected：
    
    //私有权限
    private：
    （银行卡密码，外界不可改）
}
int main(){
    //示例化具体对象
}

class 类名{
	//访问权限三种：1、公共权限public    成员 类内可以访问   类外可以访问
		       2、保护权限protected 成员 类内可以访问   类外不可以访问  
		       3、私有权限private   成员 类内可以访问   类外不可以访问
			（学习到继承的时候会看到保护权限和私有权限的区别：
			  儿子可以访问父亲中的保护内容
   			    儿子不可以访问父亲中的私有内容）
	//公共权限
	public：
		属性（半径）
		int m；
		行为（获取圆的周长）
		double


	//保护权限
	protected：
	
	//私有权限
	private：
	（银行卡密码，外界不可改）
}
int main(){
	//示例化具体对象
}

二、struct与class区别

默认的访问权限不同，struct默认公有；class默认私有。

三、成员属性设置为私有

利处：1.将所有成员属性设置为私有，可以自己控制读写权限
           2.对于写权限，可以检测数据的有效性

class student{
public：
	//姓名 设置可读可写
	//设置姓名（写）
	void setName(string name)
	{
		m_Name=name;
	}
	//获取姓名（读）
	string getName(){
		return m_Name;
	}


	//年龄  设置只读
	//获取年龄（读）
	int getAge（）{
		m_Age=0;//因为只能读，所以先顺带在类中初始化
		retrun m_Age;
	}

	//情人 设置只写
	//设置情人（写）
	void setLover(string lover){
		m_Lover=lover;
	} 

private：
	//姓名 设置可读可写
	string m_Name;

	//年龄 只读
	int m_Age;

	//情人 只写
	string m_Lover;
	
}
int main()
{
	student t1;//实例化
	t1.setName("张三");//可写
	cout<<"姓名为："<<t1.getName()<<endl;//可读

	cout<<"年龄为："<<t1.getAge()<<endl;//只读
	
	t1.setLover("李卿婵");//可写
	cout<<"情人为："<<t1.setLover（）<<endl;//不可读
	
}

四、类的函数传递

1、全局函数：（函数在类外面）
void x(cube  c1, cube c2)(类，一个类元素)，这样子值传递会拷贝一份数据 
void x(cube &c1, cube &c2)  ，指针引用就不会拷贝一份数据了
主函数里：x(c1,c2)

2、成员函数：（函数在类里面）
在类里，已经存在一个c（即c1）了，这时候只需要再传一个c（即c2），进行比较即可：

class cube{
	public:
	int getL(){
		return m_L;
	}
	int geth(){
		return m_h;
	}
	int getw(){
		retrun m_w;
	}
	bool x(cube &c){
		m_L==c.getL()//传进来的数据与自身数据比较
	}
	private:
	int m_L,m_h,m_w;
}
int main(){
	cube c1;
	c1.setL(10);c1.setw(10);c1.seth(10);
	cube c2;
	c2.setL(10);c2.setw(10);c2.seth(10);

	c1.x(c2);c2这个类传递到c1的这个类里的x函数（solid work装配体）：c1的函数被c2传进去
}

五、把类拆分到一个文件（分模块，另起.cpp与.h文件）

头文件创建.h
point.h:

#pragma once防止头文件重复包含
#include<iostream>
using namespace std;
class Point{
public:
	void setX(int x);
	int getX();
	void setY(int y);
	int getY();
private:
	int m_X;
	int m_Y;
}只留声明

源文件创建.cpp
point.cpp

#include"point.h"
void Point::setX(int x)
{
	m_X=x;
}
int Point::getX()
{
	return m_X;
}
void Point::setY(int y)
{
	m_Y=y;
}
int Point::getX()
{
	return m_X; 
}
point作用下的成员函数-->Point::

六、对象的初始化和清理和分类及调用

1 构造函数和析构函数
        C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。
1.1、构造函数:主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
   构造函数语法: 类名(){}
   1）构造函数，没有返回值也不写void
   2）函数名称与类名相同
   3）构造函数可以有参数，因此可以发生重载
   4）程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次
1.2、析构函数:主要作用在于对象销毁前系统自动调用]执行一些清理工作。
   析构函数语法:  ~类名(){}
  1）析构函数，没有返回值也不写void
  2）函数名称与类名相同,在名称前加上符号 ~
  3）析构函数不可以有参数，因此不可以发生重载
  4）程序在对象销毁前会自动调用析构，无须手动调用.而日只会调用一次

#include<iostream>
#include<string>
using namespace std;
class person {

public:
    //1、构造函数
        //1）构造函数，没有返回值也不写void
        //2）函数名称与类名相同
        //3）构造函数可以有参数，因此可以发生重载
        //4）程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次
    person() {
        cout << "person构造函数的调用" << endl;
    }

    //2、析构函数
        //1）析构函数，没有返回值也不写void
        //2）函数名称与类名相同, 在名称前加上符号 ~
        //3）析构函数不可以有参数，因此不可以发生重载
        //4）程序在对象销毁前会自动调用析构，无须手动调用.而日只会调用一次
    ~person() {
        cout << "person的析构函数调用" << endl;
    }

};
//构造和析构都是必须有的实现，如果我们不提供，编译器会提供一个空实现的构造和析构
void test01() {
    person p;//在栈区的数据（局部变量），test01执行完毕后，就会释放这个对象，所以在释放这个对象前（对象销毁前），它就会自动调用这个析构函数
}
int main() {
    //test01();//这里只是调用了一下test01，他就自动调用了一次class类里面的函数，如果不写class里面的这个person函数，他也会自己生成调用，只不过它生成的person函数里面是空的
    person p;//当不调用test01时，不会被释放（销毁）正常是结果先显示“person的构造函数调用”，然后按任意键，一瞬间它才会释放，执行析构函数的操作，但不知道为何在m visual studio2022会两个都显示 
}

2.1构造函数的分类及调用

     两种分类方式：1）按参数分为：有参构造和无参构造

                               2）按类型分为：普通构造和拷贝构造

     三种调用方式：括号法   显示法   隐式转换法

     2.1.1 普通构造包括有参和无参：

      （1）无参构造（也称为默认构造函数）

    //无参构造（默认构造，（这个函数不写，编译器也会自动编写一个））    
    person() {
        cout << "person的无参构造函数的调用" << endl;
    }

     （2）有参构造

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

2.1.2拷贝构造

 // 拷贝函数：const是防止张三拷贝进来改成了李四，引进方式用地址符&
 //2、析构函数
class person{
public: 
    person(const person &p) {
        cout << "person的拷贝构造函数调用" << endl;
        //将传入的人身上的所有属性，拷贝到我身上
        age = p.age;
    }
    int age;

}

2.2调用方法

       括号法                        显示法                   隐式转换法

2.2.1括号法

void test01() {
    //1、括号法
    person p1;//默认（无参构造）函数的调用
    person p2(10);//有参构造函数 
    person p3(p2);//拷贝构造函数
    cout << "p2年龄为：" << p2.age << endl;
    cout << "p3年龄为：" << p3.age << endl;
    //注意事项：调用默认构造函数时候，不要加（），因为如果加了括号，即
    // "person p1();",编译器会认为这一代码是一个函数的声明
    // （person是函数返回类型，p1是函数名再加个（））
}

注意事项：调用默认构造函数时候，不要加()，因为如果加了括号，即"person p1();",编译器会认为这一代码是一个函数的声明（person是函数返回类型，p1是函数名再加个() ）

2.2.2显示法

void test01(){
//2、显示法
    person p4;
    person p5 = person(10);//p5、p6为这些匿名对象的名
    person p6 = person(p5);
    //单独把右边的拿出来，其属于匿名对象
    person(10);//匿名对象，特点：当前执行结束后，系统会立即回收掉匿名对象
}

注意事项：

        不要利用拷贝函数构造函数来初始化匿名对象如person(p3)；编译器会默认为person(p3)====person p3;变成了无参构造函数，上面已经存在一个p3了，这里再来一个，重定义了

2.2.3隐式转换法

void test01(){    
    person p7 = 10;//有参构造，相当于写了person p4=person(10);
    person p8 = p7;//拷贝构造
}

2.3整体代码：

#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //1、构造函数
    //无参构造（默认构造，（这个函数不写，编译器也会自动编写一个））    
    person() {
        cout << "person的无参构造函数的调用" << endl;
    }
    //有参构造
    person(int a) {
        age = a;
        cout << "person的有参构造函数的调用" << endl;
    }
    //以上两种皆为普通构造
    // 拷贝函数：const是防止张三拷贝进来改成了李四，引进方式用地址符&
    //2、析构函数
    person(const person &p) {
        cout << "person的拷贝构造函数调用" << endl;
        //将传入的人身上的所有属性，拷贝到我身上
        age = p.age;
    }
    int age;
};

//调用：括号法  显示法  隐式转换法

void test01() {
    //1、括号法
    person p1;//默认（无参构造）函数的调用
    person p2(10);//有参构造函数 
    person p3(p2);//拷贝构造函数
    cout << "p2年龄为：" << p2.age << endl;
    cout << "p3年龄为：" << p3.age << endl;
    //注意事项：调用默认构造函数时候，不要加（），因为如果加了括号，即
    // "person p1();",编译器会认为这一代码是一个函数的声明
    // （person是函数返回类型，p1是函数名再加个（））
    //2、显示法
    person p4;
    person p5 = person(10);//p5、p6为这些匿名对象的名
    person p6 = person(p5);
    //单独把右边的拿出来，其属于匿名对象
    person(10);//匿名对象，特点：当前执行结束后，系统会立即回收掉匿名对象
    //注意事项：不要利用拷贝函数构造函数来初始化匿名对象
    // 如person(p3)；编译器会默认person(p3)====person p3;
    // 变成了无参构造函数，上面已经存在一个p3了，这里再来一个，重定义了
    
    
    //3、隐式转换法
    person p7 = 10;//有参构造，相当于写了person p4=person(10);
    person p8 = p7;//拷贝构造

}
int main() {
    test01();
}

七、拷贝构造函数的调用时机

三种情况：

#使用一个已经创建完毕的对象来初始化一个新对象

#值传递的方式给函数参数传值

#以值方式返回局部对象

#include<iostream>
#include<string>
using namespace std;
class person {
public:
    //无参构造
    person() {
        cout << "person的无参构造函数的调用" << endl;
    }
    //有参构造
    person(int a) {
        m_age = a;
        cout << "person的有参构造函数的调用" << endl;
    }
    //拷贝构造
    person(const person &p) {
        cout << "person的拷贝构造函数调用" << endl;
        m_age = p.m_age;
    }
    ~person() {
        cout<<"person析构函数的调用" << endl;
    }
    int m_age;
};

7.1使用一个已经创建完毕的对象来初始化一个新对象

//1、使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
    person p1(20);//有参函数的括号法调用
    person p2(p1);//拷贝函数的括号法调用
}

7.2值传递的方式给函数参数传值

//2、值传递的方式给函数参数传值
void dowork1(person p) {
    //拷贝了临时的副本出来，更改不会改变原来的数据
}
void test02() {
    person p;
    dowork1(p);
}

7.3值方式返回局部对象

person dowork2() {
    person p1;
    return p1;//返回一个类对象
}

int main() {
    test01();
    test02();
    test03();
    system("pause");
    return 0;
}

八、构造函数的调用规则

默认情况下，c++编译器至少给一个类添加3个函数
#1 默认构造函数(无参，函数体为空)
#2 默认析构函数(无参，函数体为空)
#3 默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：

//如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

//如果用户定义拷贝构造函数，c++不会再提供其他构造函数

九、深拷贝与浅拷贝

                       深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝: 简单的赋值拷贝操作
深拷贝: 在堆区重新申请空间，进行拷贝操作

先看一串代码：

#include<iostream>
#include<string>
using namespace std;
class person {
public:
	person() {
		cout<<"默认构造" << endl;
	}
	person(int age, int height) {
		m_age = age;
		m_height = new int(height);//并不是直接赋值，而是利用new把这个数据创建在堆区，new int（变量），返回的是int*
		//m_heght为int*，接收后面
		cout<<"有参构造" << endl;
	}
	~person() {
		//析构代码，将堆区开辟的数据做释放操作
		cout<<"析构函数" << endl;
	}
	int m_age;//年龄
	int *m_height;//身高,用指针是为了把身高的数据开辟到堆区，由于上面是用new+int()返回的是int*，所以这里用int*来接收
};
void test01() {
	person p1(18,175);
	cout << "p1的年龄为：" << p1.m_age << "身高为：" << *p1.m_height << endl;
	person p2(p1);
	cout << "p2的年龄为：" << p2.m_age << "身高为：" << *p2.m_height << endl;//加个*解引用
}
int main() {
	test01();
}

此时虽然程序能正常运行，但是存在一点的问题，堆区的开辟的数据由程序员手动开辟也需要由程序员手动释放，那么这个数据什么时候给他释放呢。就是在这个对象在销毁前，把这个堆区的数据释放掉。比如test01执行完了，p1和p2就会销毁了，那么p1和p2销毁前会调用什么函数，答案是析构。因为在析构的时候，应该把他自身在堆区开辟的空间给他释放干净，那么此时析构代码就产生作用了：将堆区开辟数据做释放操作，判断一下即可：

	~person() {
		//析构代码，将堆区开辟的数据做释放操作
		if (m_height!=NULL) {//如果身高这个指针不等于空
			delete m_height;
			m_height = NULL;//再置空身高，防止野指针出现
		}
		cout<<"析构函数" << endl;
	}

但是此时会报错，接下来的报错就是浅拷贝造成的，对该错误进行解释

先看年龄，当写了年龄为18之后，如果利用编译器提供的拷贝构造函数，会做浅拷贝的操作，就相当于用拷字节的方式把18的字节一个一个拷过去右边p2的m_age。那么再看身高（也是这里出现了问题），这是一个指针，这个指针是在堆区开辟了一块内存用来存放160这个数据，假设这个堆区的地址编号为0x0011，同样左边记录的也是0x0011，当浅拷贝时，它相当于把左边p1的0x0011直接复制到右边p2的m_height上，所以左边记录的指针也是0x0011。那么析构代码执行时候，p1和p2都会执行析构（先进后出，p2是进来的先释放），p2被释放之后（把堆区的内存释放了），轮到p1析构时，它也来释放堆区这块内存，此时非法操作，即浅拷贝带来的问题内存被重复释放。

解决办法：深拷贝解决

在堆区重新申请空间，进行拷贝操作。之前的拷贝构造函数是编译器自己写的，我自己可以重新在堆区申请一块内存，这块内存也存放160，但它的地址可能不是0x0011，而可能是0x0022。那么此时不让p2指向0x0011堆区了，而是指向0x0022这堆区，此时右边记录的是0x0022，实现如下，在析构函数前面写一个开辟另一内存的函数：

	//自己实现一个拷贝函数来解决浅拷贝的问题
	person(const person& p) {
		cout<<"深拷贝构造函数的调用" << endl;
		m_age = p.m_age;
		//m_height = p.m_height;//编译器默认就是这行代码
		//接下来深拷贝操作
		m_height=new int(*p.m_height);

	}

十、初始化列表

C++提供了初始化列表语法，用来初始化数属性

语法：

构造函数（）：属性1（值1），属性2（值2）...

{

        ..........

}

person(int a,int b,int c) :m_A(a), m_B(b), m_C(c)
{

}

与传统方式相对比：

#include<iostream>
using namespace std;
class person {
public:
	//1、传统初始化操作
	//person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}
	//2、初始化列表 初始化属性
	person(int a,int b,int c) :m_A(a), m_B(b), m_C(c)
	{

	}
	int m_A;
	int m_B;
	int m_C;
};
void test01() {
	//person p(10,20,30);//1、传统
	person p(10,20,30);//这样子相当于创建函数对象的同时，调用了构造函数，顺便将它的属性赋值了10，20，30
	cout << "m_A=" << p.m_A << endl;
	cout << "m_B=" << p.m_B << endl;
	cout << "m_C=" << p.m_C << endl;
}
int main() {
	test01();
	system("pause");
}

十一、类对象作为类成员

C++类中的成员可以是另一个类的对象，称该成员为 对象成员

和内嵌结构体相似

如：B类中有对象A作为成员，A为对象成员

class Phone{
public:
	string m_PName;
	Phone(string pName)
	{
		m_PName = pName;
	}
};
//人
class Person {
public:
	//姓名
	string m_Name;
	Phone m_Phone;
	Person(string name, string pName):m_Name(name),m_Phone(pName)
	{
		m_Name = name;
	}
};

那么当创建B对象时，A与B的构造和析构函数的顺序是谁先谁后

构造函数：先构造小对象，在构造大对象，无子何来整。

析构函数：与构造函数相反

十二、静态成员

在成员变量和成员函数前加上关键字 static ，成为静态成员：

静态成员分为：

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

2.静态成员函数
（1）所有对象共享同一个函数
（2）静态成员函数只能访问静态成员变量

1.1类外初始化：

#include<iostream>
using namespace std;
#include<string>
class A {
public:
	static int m_A;
};
void test01() {
	A p;
	cout<<p.m_A<<endl;
}
int main() {
	test01();
}

此时已经将m_A定义为了一个静态变量，但是它虽然在类声明了，但是却没有类外初始化，这样子的后果是:

所以要进行类外初始化操作：告诉它，Person作用域下面的m_A的操作（类型中把static去掉）：

//类外加上类外初始化语句
int A::m_A = 100;

1.2 共享性：

void test01() {
	A p;
	cout << p.m_A << endl;
	A P2;
	P2.m_A = 200;
	cout << p.m_A << endl;
}

重新创建了类成员P2，并且改变了m_A=200，由于m_A是静态，即为所有类成员对象共享m_A这份数据，那么最后m_A改了什么，就是什么。结果为：

那么由于静态成员变量 不属于某个对象上，所有对象都共享同一份数据，因此静态成员变量有两种访问方式：

     #通过对象进行访问
     #通过类名进行访问

void test02() {
	//静态变量访问的两种方式
	//1、通过对象进行访问
	A P3;
	cout<<P3.m_A<<endl;
	//2、通过类名进行访问
	cout << A::m_A << endl;
}

注意：静态变量也会有访问权限的，当它在private下定义时，类外访问不了。

2.1共享同一个函数

那么由于静态函数不属于某个对象上，所有对象都共享同一份数据，因此静态函数有两种访问方式：

     #通过对象进行访问
     #通过类名进行访问

class A {
public:
	static void func() {

	}
};
void test() {
	//1、通过对象访问
	A p;
	p.func();
	//2、通过类名访问
	A::func();
}

 注意：静态成员函数不可以访问非静态成员变量（m_B报错）

            静态函数也有访问权限，类外不能访问private里的静态函数；

因为无法区分到底是哪个对象的m_B属性，m_B是非共享的，

而m_A是共享的，可以直接访问

十三、 对象模型与this指针

1、成员函数和成员变量分开存储，只有非静态成员变量才属于类的对象上

（非静态成员变量占对象空间）

1.1静态成员不在类上，非静态成员才在类上：

#include<iostream>
using namespace std;
class Person {
public:

};
void test01() {
	Person p;
	cout << "size of p =" << sizeof(p) << endl;
}
int main() {
	test01();
}

 可见，空对象的占用内存为1，C++编译器会给每一个空对象也分配一个字节的空间，用来区分空对象占内存的位置，（总不能所有空对象公用一个内存空间吧），每一个对象也应该有一个独一无二的内存地址。

假如类里面定义了一个非静态成员，如int A；那么此时分配给类的内存就是非静态变量的类型的内存，所以此时为4字节；当再在类里面加入 static int m_B;内存依旧为4，因为静态成员不属于类对象上。

当类里面在加入一个非静态函数void func(){},输出类占用的内存依旧是4字节，这就是所说的成员函数和成员变量分开存储，也不在类上；当类里面加入静态函数时，输出类的占用内存依旧是4字节，原因相同。

总结：只有非静态成员变量才属于类的对象上

十四、this指针概念

       通过十三我们知道在C++中成员变量和成员函数是分开存储的每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码那么问题是: 这一块代码是如何区分那个对象调用自己的呢?
c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象
####  this指针是隐含每一个非静态成员函数内的一种指针

####  this指针不需要定义，直接使用即可

this指针的用途:
1）当形参和成员变量同名时，可用this指针来区分（解决名称冲突）
2）在类的非静态成员函数中返回对象本身，可使用return *this（返回对象本身用*this）

看程序：当形参和成员变量同名时：

可见编译器自始至终都没有将类成员传进去，因为形参和成员变量同名，他把里面的等号左边的age当作形参了， age=age也没毛病，解决办法就是用this->指针来age，这时候：

这时候阴影对应可看出可以区分开形参和成员变量了，并且成功对成员变量进行了赋值

（写程序时尽量不要让形参与成员变量同名）

 再看这串代码：

class person {
public:
	person(int age) {
		this->age = age;
	}
	int age;
	void personkkky(person &p){
		this->age += p.age;
	}
};
//2、返回对象本身用*this
void test02() {
	person p1(10);
	person p2(10);
	p2.personkkky(p1);
	cout<<p2.age<<endl;

}
int main() {
	test02();
}

在p2.personkkky(p1)，可以再加几个personkkky(p1),即 

但是会报错，为什么，因为 p2.personkkky(p1)返回的是void类型，那么返回值是void，那么后面的两个函数肯定不能调用。但是事实上p2.personkkky(p1)是可以继续调用的，当p2.personkkky(p1)调完一次这个函数后返回的还是p2，那么就可以调用了，如图：

解决办法是：在调用的函数里，返回对象本身：

函数里加入返回*this，this指向p2的指针，而*this指向的就是p2的这个本体，既然返回本身，那么就要把void改为person&（本体&），引用的方式返回。

同时，下面这种思想也是链式编程思想，无限追加。

注意：当本体引用去掉&，返回的是一个值，那么后面链式那返回的就不是p2了，而是重新创造的p2‘，p2’‘。

十五、空指针访问成员函数

C++的空指针也可以调用成员函数的，但是也要注意有没有用到this指针，如果用到this指针，需要加以判断保证代码的健壮性。

代码示例：

当两个函数都用时，报错：

#include<iostream>
using namespace std;
class person {
public:
	void showClassName() {
		cout << "haha " << endl;
	}
	void showclassname() {
		cout<<"hh=" <<age<< endl;
	}
	int age;
};
void test() {
	//创建一个空指针
	person* p = NULL;
	p->showClassName();
	p->showclassname();
}
int main() {
	test();
}

 运行后结果：

当只用1函数showClassName()时运行结果无报错：

当只使用函数showclassname()时运行结果报错：

 原因分析：说明函数一没问题，函数二有问题，因为第二个函数调用了一个age属性，其实在属性前面都默认加了一个箭头this->指向当前对象的属性，当this指向一个空指针，一个空的值去访问一个属性，无中生有。

 解决办法是，提前在this->之前做一次判断，如果为空，则退出。

if(this==NULL){
    return;
}

十六、const修饰成员函数

（1）常函数：

1.1、成员函数后加const后我们称为这个函数为常函数

1.2、常函数内不可以修改成员属性

1.3、成员属性声明时加关键字mutable后，在常函数中依然可以修改

（2）常对象:

2.1、声明对象前加const称该对象为常对象

2.2、常对象只能调用常函数

代码解析：

1.1、成员函数后加const后我们称为这个函数为常函数

1.2、常函数内不可以修改成员属性

class person {
public:
	void showClassName() {
		age = 10;
	}
	int age;
};

原本可以修改，加了const在函数后面之后不可更改，因为无论传不传参数进去，里面默认有一个this->指针，this指针的本质就是指针常量，指针常量的特点是指针的指向是不可以修改的，但是this指针指向的值是要修改的（图2）

 如果想让值也不可以更改，再在person *const this前面加上const即可，相当于成员函数名后加const，成员函数名后加const，修饰的是this指向，让指针指向的值也不可以进行修改。

1.3、成员属性声明时加关键字mutable后，在常函数中依然可以修改

2.1、声明对象前加const称该对象为常对象

值不可修改，否则报错

2.2、常对象只能调用常函数

十七、全局函数做友元

特别的人特别对待

生活中你的家有客厅(Public)，有你的卧室(Private)

        客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去。但是呢，你也可以允许你的好朋友进去
        在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术，友元的目的就是让一个函数或者类 访问另一个类中私有成员，友元的关键字为 friend
友元的三种实现
1、全局函数做友元
2、类做友元
3、成员函数做友元

1、全局函数做友元：

private下的普通成员不能类外访问，这时候只需要把函数名放进去类中用友元符号friend即可，意思是goodGay全局函数是Building好朋友，也可以访问。 

十八、友元类

（2、类做友元）

#include<iostream>
using namespace std;
//人
class goodperson1 {
public:
	goodperson1();
	void visit();
private:
	Building* building;
};
//房子
class Building {
public:
	Building();
	string sittingroom;
private:
	string bedroom;
};
goodperson1::goodperson1() {
	building = new Building;
}
Building::Building() {
	this->sittingroom = "客厅";
	this->bedroom = "卧室";
}
void goodperson1::visit() {
	cout << building->sittingroom << endl;
	cout << building->bedroom << endl;
}
void test() {
	goodperson1 n;
	n.visit();
}
int main() {
	test();
}

此时访问私有成员会报错：

在building中放入friend goodperson1，将这位朋友定为好友，即可访问。

十九、成员函数做友元

  friend   函数类型 类别 ：：函数；

二十、运算符重载

对已有的运算符重新进行定义，赋予它另一种功能，以适应不同的数据类型。

语法：operator 运算符（参数）

（1）加号运算符重载+自定义相加

实现两个自定义数据类型相加的运算

下面开始运算符重载：

1、成员函数重载+号

本质：person p3=p1.operator+(p2);

#include<iostream>
using namespace std;
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;
};
void test01() {
	person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	person p2;
	p2.m_A = 20;
	p2.m_B = 20;
	person p3 = p1 + p2;
	cout << "p3.m_A=" << p3.m_A << endl;
	cout << "p3.m_B=" << p3.m_B << endl;
}
int main() {
	test01();
}

2、全局函数重载+号

本质：person p3=p1+p2;

#include<iostream>
using namespace std;
class person {
public:
	int m_A;
	int m_B;
};
//2、全局函数重载+号
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 test01() {
	person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	person p2;
	p2.m_A = 20;
	p2.m_B = 20;

	person p3 = p1 + p2;
	cout << "p3.m_A=" << p3.m_A << endl;
	cout << "p3.m_B=" << p3.m_B << endl;
}
int main() {
	test01();
}

3、函数重载 版本

#include<iostream>
using namespace std;
class person {
public:
	int m_A;
	int m_B;
};
//2、全局函数重载+号
//person operator+(person& p1, person& p2);
//函数重载版本
person operator+(person& p1, int num) {
	person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}
void test01() {
	person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	person p2;
	p2.m_A = 20;
	p2.m_B = 20;
	person p4 = p1 + 10;//person+int
	cout << "p4.m_A=" << p4.m_A << endl;
	cout << "p4.m_A=" << p4.m_B << endl;
}
int main() {
	test01();
}

（2）左移运算符重载<<自定义数据类型

1、成员函数重载+号

2、全局函数重载+号

3、函数重载 版本

（3）递增运算符重载

（4）赋值运算符重载

（5）关系运算符重载

（6）函数调用运算符重载

B.继承（面向对象三大特征之一）

一、定义

 class 类名：public  类名{  }

class 子类（派生类）：继承方式  父类（基类）

派生类里有两部分：一部分是基类继承过来的（共性），一部分是自己增加的成员（个性）

二、继承方式

（1）公共继承

其他不变，私有权限private不可访

（2）保护继承

公有变保护，私有不可访

（3）私有继承

公有变私有，保护不能访问

三、继承中的对象模型

（从父类继承过来的成员，哪些属于子类对象，全部非静态成员）

#include<iostream>
using namespace std;
class A {
public:
	int a;
protected:
	int b;
private:
	int c;
};

class B :public A {
public:
	int d;
};
void kdd() {
	cout << sizeof(B) << endl;
}
int main() {
	kdd();
	
}

输出结果为16，说明子类继承了父类所有非静态成员内存，并且加上了自身的内容。

如果想看到被隐藏的数据，可以：

四、继承中构造和析构顺序

（构造：现有父亲再有儿子，析构：父亲走在儿子前面（从上往下））

五、继承同名成员处理方式

情况：子类与父类有相同名字的成员，当用子类访问时：

访问子类同名成员，直接访问

访问父类同名成员，加作用域访问

A.B:c;

六、继承同名静态成员处理方式

和非静态处理方式一样，只不过有两种访问方式（通过对象和类名）

 

 注意：

七、多继承语法

语法：class子类：继承方式 父类，继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

（实际开发中不建议用，但要知道掌握）

#include<iostream>
using namespace std;
class Base1 {
public:
	Base1() { m1 = 10; }
	int m1;
};
class Base2 {
public:
	Base2() { m1 = 20; }
	int m1;
};
//子类 需要继承Base1和Base2
class son :public Base1, public Base2 {
public:
	son() {
		m_son1 = 30;
		m_son2 = 40;
	}
	int m_son1;
	int m_son2;
};
void test01() {
	son s;
	cout << "sizeof=" <<sizeof(son)<< endl;//放创建的对象s也一样
	//问题：当两个父类里有同名成员，当通过子类访问时，会出现错误
	//cout << s.m1 << endl;
	//此时需要加作用域区分
	cout << s.Base1::m1 << endl;
	cout << s.Base2::m1 << endl;
}

int main() {
	test01();
	system("pause");
}

当两个父类里有同名成员，当通过子类访问时，会出现错误,此时需要加作用域区分访问。

八、菱形继承

两个派生类继承同一个基类，又有某个类同时继承着两个派生类。

典型案例：

当羊驼定义从前面继承下来的变量时，会发生冲突（同上面的多继承出现的问题大致）

#include<iostream>
using namespace std;
//动物类1
class animal {
public:
	//animal() { m1 = 10; }
	int age;
};
//羊类2
class sheep:public animal {
public:		
};
//驼类2
class Tuo :public animal {

};
//羊驼类3
class sheepTuo :public sheep, public Tuo {

};
void test01() {
	sheepTuo st;
	st.age = 10;
}
int main() {
	test01();
	system("pause");
}

其中st.age立马发生报错

所有当菱形继承，两个父类拥有相同的数据时，需要加以作用域区分： 

 但是此时现实问题又来了，哪个才是它的年龄，只需要一份，

利用虚继承解决菱形继承的问题：

加关键字virtual，变为虚继承，最大类为虚基类（vbptr即虚指针v-virtual，b-base,ptr-pointer,他会指向vbtable一个虚基类表）

 此时再运行就是28，因为它先18，然后按顺序相当于又改成了28，所以为28岁。

C.多态

一、定义

多态是C++面向对象三大特性之一

两类:
静态多态: 函数重载和 运算符重载属于静态多态，复用函数名
动态多态: 派生类和虚函数实现运行时多态静态多态和动态多态

区别:

静态多态的函数地址早绑定  编译阶段确定函数地址.
动态多态的函数地址晚绑定  运行阶段确定函数地址.

#include<iostream>
using namespace std;
class animal {
public:
	void speak() {
		cout << "动物在讲话" << endl;
	}
};
class cat :public animal{
public:
	void speak() {
		cout << "小猫在讲话" << endl;
	}
};
void dospeak(animal&A) {
	A.speak();
}
void test() {
	cat c;
	dospeak(c);
}
int main() {
	test();
}

上述程序运行结果为“动物在讲话”，无论传任何的猫狗，其都会输出父类的“ 动物在讲话”，因为静态多态的函数地址早绑定  编译阶段确定函数地址。要想输出子类小猫的“小猫在讲话”，则需要使用到动态多态；

前提是要父类和子类里都要有同名函数，如这里的speak，然后在父类speak函数前加上virtual即可（函数前加上virtual关键字变成了虚函数，那么编译器在编译时候就不能确定函数的调用了）

执行说话的函数
地址早绑定 在编译阶段确定函数地址
如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑，即动态多态
动态多态满足条件
1、有继承关系
2、子类重写父类的虚函数
动态多态使用：父类的指针或者引用 执行子类对象

重写：函数返回值类型  函数名  参数列表 完全一致称为重写

二、多态案例1计时器类

三、纯虚函数与抽象类

四、多态案例2制作饮品

五、虚析构和纯虚构

六、多态案例3电脑组装