C++面向对象的三大特性：封装、继承、多态
C++认为万事万物都皆为对象，对象上有其属性和行为
例如：人可以作为对象：属性有姓名，年龄，身高，体重…行为有走、跑、吃饭、唱歌…
车也可以作为对象，属性有轮胎，方向盘，车灯…行为有载人、放音乐、放空调…
具有相同性质的对象，我们可以抽象为类，人属于人类，车属于车类
1. 封装
1.1封装的意义
1.将属性和行为作为一个整体，表现生活中的事物
2.将属性和行为加以权限控制
1.1.1封装意义一：属性和行为
在设计类的时候，属性和行为写在一起，表现事物
语法 class 类名{ 访问权限： 属性 / 行为 }；
示例1：设计一个圆类，求圆的周长
#include<iostream>
using namespace std;
//圆周率
const double PI = 3.14;
//class代表设计一个类，类后面紧跟着的就是类的名称
class Circle
{
//访问权限
public: //公共权限
//属性
int m_r;//半径
//行为
double calculateZC()
{
return 2 * PI * m_r;
}
};
int main()
{
//通过圆这个类 创建具体的圆
Circle c1;
//给圆对象的属性进行赋值
c1.m_r = 10;
//2*PI*10 = 62.8
cout << "圆的周长是： " << c1.calculateZC() << endl;
system("pause");
return 0;
}
1.1.2封装的意义二：访问权限
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
1.公共的 public
2.保护权限protected
3.私有权限private
//三种权限
//公共权限：public 成员类内可以访问 类外可以访问
//保护权限：protected 成员类内可以访问 类外不可以访问 儿子可以访问父亲中的保护内容
//私有权限：private 成员类内可以访问 类外不可以访问 儿子不可以访问父亲中的私有内容
#include<iostream>
using namespace std;
class Person
{
public: //公共权限
string m_Name;//姓名
protected://保护权限
string m_Car;//汽车
private:
//私有权限
int m_Password;//银行卡密码
public:
void func()
{
m_Name = "张三";
m_Car = "拖拉机";
m_Password = 123456;
}
};
int main()
{
Person p1;
p1.m_Name = "李四";
//p1.m_Car = "奔驰";//保护权限内容，在类外访问不到
//p1.m_Password = 123;//私有权限内容，在类外访问不到
system("pause");
return 0;
}
1.2 struct和class的区别
在C++中struct和class唯一的区别在于默认的访问权限不同
区别：
struct默认权限为公共
class默认权限为私有
#include<iostream>
using namespace std;
class C1
{
int m_A;//默认权限是私有
};
struct C2
{
int m_A;//默认权限是公共
};
int main()
{
//struct和class的区别
//struct默认权限是 公共public
//class默认权限是 私有private
C1 c1;
C2 c2;
c2.m_A = 100;
system("pause");
return 0;
}
1.3 成员属性设置为私有
优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限我们可以检测数据的有效性
2.对象特性
生活中我们买的电子产品后基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
C++中面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置
2.1 构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题
- 一个对象或者变量没有初始状态，对其使用后果是未知
- 同样的使用完一个对象或者变量，没有及时清理，也会造成一定的安全问题
C++利用构造函数和析构函数解决上述问题，这两个函数被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要求我们做的事情，因此如果我们不提供构造函数和析构函数，编译器会提供
编译器提供的构造函数和析构函数是空实现
构造函数：主要作用在于创建对象时为对象的成员属性赋值，构建函数由编译器自动调用，无需手动调用
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作
构造函数语法： 类名（）{ }
- 构造函数，没有返回值也不写void
- 函数名称与类名相同
- 构造函数可以有参数，因此可以发生重载
- 函数在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次
析构函数语法： ~类名（）{ }
- 析构函数，没有返回值也不写void
- 函数名称与类名相同，在名称前加上符号~
- 构造函数不可以有参数，因此不可以发生重载
- 函数在调用对象时候会自动调用析构，无需手动调用，而且只会调用一次
#include<iostream>
using namespace std;
class Person
{
//构造函数
//1. 构造函数，没有返回值也不写void
//2. 函数名称与类名相同
//3. 构造函数可以有参数，因此可以发生重载
//4. 函数在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次
public:
Person()
{
cout << "Person 构造函数的调用" << endl;
}
//析构函数 进行清理的操作
// 1. 析构函数，没有返回值也不写void
//2. 函数名称与类名相同，在名称前加上符号~
//3. 构造函数不可以有参数，因此不可以发生重载
//4. 函数在调用对象时候会自动调用析构，无需手动调用，而且只会调用一次
~Person()
{
cout << "Person 析构函数的调用" << endl;
}
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test01()
{
Person p;//在栈上的数据，test01执行完毕后，释放这个对象
}
int main()
{
test01();
system("pause");
return 0;
}
2.2构造函数的分类及调用
两种分类方式
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
3种调用方式：
括号法
显示法
隐式转换法
#include<iostream>
using namespace std;
//构造函数的分类及调用
//分类
//按照参数分类 无参构造（默认构造）和有参构造
//按照类型分类 普通构造 拷贝构造
class Person
{
public:
//构造函数
Person()//无参
{
cout << "Person的无参构造函数调用" << endl;
}
Person(int a)//有参
{
age = a;
cout << "Person的有参构造函数调用" << endl;
}
//拷贝构造函数
Person(const Person &p)
{
//将传入的人身上的所有属性，拷贝到我身上
age = p.age;
cout << "Person的拷贝构造函数调用" << endl;
}
int age;
};
void test01()
{
//1.括号法 常用
Person p;//默认构造函数使用
Person p2(10);//有参构造函数
Person p3（p2）;//拷贝函数调用
//注意事项
// 调用默认构造函数时候，不要加（）因为下面一行代码，编译器会认为是函数的一个声明
// cout<<"p2的年龄是： "<<p2.age<<endl;
//2.显示法
Person p1;
Person p2 = Person(10);//有参构造
Person p3 = Person(p2);
//Person(10); //匿名对象 特点：当前行执行结束之后，马上析构
//3.隐式转换法
Person p4 = 10;// Person p4 = Person(10)
Person p5 = p4;//Person p5 = Person p4
//注意：不能利用拷贝构造函数 初始化匿名对象 编译器认为是对象声明
}
int main()
{
test01;
system("pause");
return 0;
}
2.3 拷贝构造函数调用时机
- 使用一个已经创建完毕的对象来初始化一个对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
2.4 构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性值进行拷贝
构造函数调用规则：
1.如果用户定义有参构造函数 ，c++不在提供默认无参构造，但是会提供默认拷贝构造
2.如果用户定义拷贝构造函数，c++不会再提供其他构造函数
2.5深拷贝与浅拷贝（面试经典问题，也是常见的坑）
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
2.6 初始化列表
C++提供了初始化列表语法，用来初始化属性
语法：构造函数 属性1（值1），属性2（值2）…{ }
2.7类对象作为类的成员
C++类中成员可以是另一个类的对象，我们称该成员为对象成员
2.8 静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
静态成员变量：1. 所有对象共享同一份数据 2.编译阶段分配内存3.类内声明，类外初始化
静态成员函数：1.所有对象共享同一个函数 2.静态成员函数只能访问静态成员变量
3.C++对象模型和this指针
3.1 成员变量和成员函数分开存储
在c++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上
3.2 this指针
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
那么问题来了：这一块代码是如何区分那个对象和调用自己的呢?
c++通过特殊的对象指针，this指针，结局上述问题，this指针指向被调用的成员函数所属的对象
this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可
this指针的用途
- 当形参与成员变量同名时，可以用this指针来区分
- 在类的非静态成员函数中返回对象本身，可使用return *this
3.3 空指针访问成员函数
c++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性
3.4 const修饰成员函数
常函数：
成员函数后加const后我们称这个函数为常函数
常函数内不可修改成员属性
成员属性声明时加关键字matable后，在常函数中依然可以修改
常对象：
声明对象前加const称该对象为常对象
常对象只能调用常函数
4. 友元
友元的目的就是让一个函数或者类 访问另一个类中私有成员
友元的关键字为 friend
友元的三种实现方式
1.全局函数做友元
2.类做友元
3.成员函数做友元
4.1全局函数做友元
4.2友元类
4.3成员函数做友元
5.C++运算符重载
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型
5.1 加号运算符重载
实现两个自定义数据类型相加的运算
5.2左移运算符重载
可以输出自定义数据类型
5.3 递增运算符重载
通过重载递增运算符，实现自己的整型数据
5.4 赋值运算符重载
c++编译器至少给一个类添加4个函数：
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性值进行拷贝
- 赋值运算符operator=，对属性进行值拷贝
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题
5.5 关系运算符重载
重载关系运算符，可以让两个自定义类型对象进行对比操作
5.6 函数调用运算符重载
函数调用运算符（）可以重载
由于重载后使用的方式非常像函数的调用，因此称为仿函数
仿函数没有固定写法，非常灵活
6. 继承
继承是面向对象三大特性之一：
有些类与类之间存在特殊的关系，如图
6.1基本语法
继承的好处：可以减少重复的代码
class A:public B;
A类称为子类或者派生类；
B类称为父类或者基类；
派生类中的成员，分为两大部分：
一类是从基类继承过来的，一类是自己增加的成员
从基类继承过来的表现其共性，而新增的体现了其个性
6.2 继承方式
继承语法; class 子类：继承方式 父类
继承方式一共有3类
公共继承
保护继承
私有继承
6.3 继承中的对象模型
问题：从父类继承过来的成员，哪些属于子类对象中？
父亲中的私有成员也是被子类继承下去了，只是被编译器隐藏后访问不到
6.4 继承中构造和析构顺序
子类继承父类后，当创建子类对象，也会调用父亲的构造函数
问题;父类和子类的构造和析构顺序是谁先谁后？
继承中，先调用父类构造函数，再调用子类构造函数，析构顺序与构造顺序相反
6.5 同名成员的处理
问题：当子类与父类出现同名的成员时，如何通过子类对象，访问到子类或父类中同名的数据呢？
访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用域
1.子类对象可以直接访问到子类中同名成员
2. 子类对象加作用域可以直接访问到父类同名成员
3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中的同名成员函数，加作用域可以访问到父类中同名函数
6.6 同名静态成员处理
问题;继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致
访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用域
静态成员和非静态成员出现同名，处理方式一致，只不过有两种访问的方式（通过对象 和 通过类名）
6.7多继承语法
C++允许一个类继承多个类
语法：calss 子类 ： 继承方式 父类1，继承方式 父类2…
多继承可能会引发父类中有同名成员出现，子类使用时需要加作用域区分
C++实际开发中不建议用多继承
7. 多态
7.1多态的基本概念和原理剖析
多态是C++面向对象三大特性之一
多态分为两类：
静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态区别：
- 静态函数的函数地址早绑定：编译阶段确定函数地址
- 动态函数的函数地址晚绑定：运行阶段确定函数地址
多态满足条件：
3. 有继承关系
4. 子类重写父类中的虚函数
多态使用条件
父类指针或引用指向子类对象
重写：函数返回值类型 函数名 参数列表
//完全一致称为重写
7.2 纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法： virtual 返回值类型 函数名 {参数列表} = 0；
当类中有了纯虚函数，这个类也称为抽象类
抽象类特点
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
7.3 虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方法：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构与纯虚析构区别：
如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构语法
virtual ~类名
纯虚析构语法
virtual ~类名（） = 0
类名：：~类名（）{ }
总结：
1.虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
3. 拥有纯虚析构函数的类也属于抽象类
扫一扫
18万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
