0.前言
最近在做算法移植的时候，发现自己对c++的知识忘得很多，于是就计划重新捡起来。
纸上得来终觉浅，绝知此事要躬行
一直都是我学习和工作的原则，我比较喜欢动手。
于是我把c++的基础知识一行行代码敲了一遍，无论多简单！
1.内存分区模型
c++内存分为4个区域：
-
代码区：存放函数体的二进制代码，由操作系统进行管理。
-
全局区：存放全局变量、静态变量、常量
-
栈区：由编译器自动分配释放，存放函数的参数值、局部变量等。
-
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
内存分区的意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程。
1.1 程序运行前
在程序编译后，生产了exe可执行程序，未执行该程序前分为
代码区：
存放cpu执行的机器指令
1.共享：目的是对于频繁被执行的程序，只需内存中由一份代码即可。
2.只读：防止程序被随意修改指令
全局区：
全局变量包含常量区：字符串常量和其他常量
程序结束后，系统自己释放全局区的数据
const修饰的局部变量(局部常量),不放在全局区，而是放在栈区
int fun() {
const int a =10;//局部常量
}
总结：
- c++在exe程序运行前分为全局区和代码区
- 代码区的特点是只读和共享
- 全局区中存放全局变量 静态变量 常量
- 常量区中存放const修饰的全局变量(即全局常量) 和 字符串常量
1.2 程序运行后
栈区
由编译器自动分配和释放，函数的参数，局部变量等
注意事项：不与返回局部变量的地址，栈区开辟的数据在函数结束后，编译器会自动释放
堆区
由程序员分别和释放，若程序员不释放，程序结束后，系统会自己释放，如果程序不结束，系统就永远不释放。
c++中主要用new在堆区申请内存
1.3 new的用法
new申请，务必使用delete释放
int *a = new int(10);
delete a;
int *b = new int [8];
delete [] b;//数组释放要加[]
2.引用
2.1 引用的基本使用
作用：给变量起别名
语法：数据类型 &别名 = 原名
int a =10;
int &b = a;
(本质上：int *const b = &a)
2.2 引用的注意事项
- 1.引用必须要初始化
int &b;//错误 - 2.引用在初始化后，不可以改变
int a =10;
int &b = a;
int c =20;
b = c;//赋值操作，而不是更改引用
2.3 引用做函数参数
作用:函数传参时，可以利用引用的技术，让形参修饰实参
优点：可以简化指针修改实参
void swap(int &a,int &b) {
int temp = a;
a = b;
b = temp;
}
2.4 引用做函数返回值
作用：引用可以作为函数的返回值
注意：不要返回局部变量的引用
用法：函数调用作为左值
int& fun()
{
static int a =10;
return a;
}
int &ref = fun();
fun()= 100;//函数调用可以作为左值 被赋值
2.5 引用的本质
本质：引用的本质在c++内部实现是一个指针常量（指向不变，里面的值可变）
//编译器发现这里是引用，转换位int * const ref = &a;
void func(int & ref) {
ref = 100;//ref是引用，转换位*ref = 100
}
int main(){
int a=10;
int& ref = a;
//自动转换为 int* const ref = &a;
//指针常量是指向不可更改，值可改，也说明为什么引用不可更改
ref = 20;//发现是引用，自动转换成 *ref =20
}
结论：c++途径用引用计数，因为语法方便，引用的本质是指针常量，但是所有指针的操作，编译器都帮我们做了
常量引用
作用：常量引用主要用来修饰形参，防止误操作
const int & a;
int &ref =10;//这是错误的，引用必须引用一块合法的内存,10在常量区，访问时必须加const
int &ref =10;//这是错误的，引用必须引用一块合法的内存
const int &ref =10；//合法
//加上const之后，编译器把代码修改成
/*
int temp =10;
const int &ref = temp;
*/
//常量引用使用场景：通常用来修饰形参，防止函数改值
void printValue(const int&a){
//a=20；报错
print("a=%d",a);
}
3.函数提高
3.1 函数的默认参数
在c++中，函数的形参是可以有默认值的。
语法： 返回值 函数名 (参数 = 默认值) { }
int func(int a,int b=1, int c =2) {
}
-
如果形参中某个位置有了默认参数，从这个位置往后，从左往右都必须有默认参数
-
如果函数声明有默认参数，函数实现就不能有默认参数，否则会报错：重定义默认参数
int fun2(int a =10);//声明
int func2(int a =10){//实现
}
这样会报错
3.2 函数占位参数
c++中的函数的形参是可以有占位参数的，用来做占位，调用函数时必须填补该位置。
语法： 返回值 函数名 （数据类型）{ }
//占位参数-第二个参数
void func(int a,int) {
}
//占位参数 还可以有默认参数
void func2(int = 10){
}
int main(){
func(10,10);
}
3.3 函数重载
3.3.1 函数重载概述
作用：函数名可以相同，提高复用性
函数重载满足条件
- 同一个作用域下
- 函数名相同
- 函数参数 类型不同 或者 个数不同 或者 顺序不同
注意：函数返回值 不可以作为函数重载的条件
void fun();
void fun (int a,float b)
void fun (float b,int a)
//int fun (float b,int a) 这个会报错，二义性
3.3.2 函数重载注意事项
- 引用作为重载条件
//1.引用作为重载条件
void func(int &a){ //int& a =10 ；不合法
}
void func(const int &a){const int &a = 10 合法
}
这两个是函数重载 int 和 const int算不同类型
int main(){
int a =10;
func(a);//此时调用第1个void func(int &a)，
//如果void func(int &a)没定义，就调用第2个
func(10);//此时调用第2个void func(const int &a)
}
- 函数重载碰到默认参数
void func(int a){ //int& a =10 ；不合法
}
void func(int a,int b =10){
}
fun(10);//这里编译器不知道调用哪个了
这里函数会出现二义性，会报错，
一般写函数重载时，就别写默认参数了
4.类和对象
万事万物皆为对象，包含属性和行为
c++面向对象的三大特性：封装、继承、多态
4.1 封装
4.4.1 封装的意义
封装是c++面向对象的三大特性之一
意义：
- 将属性和行为作为一个整体，表现生活中的事物
- 将属性和行为加以权限控制f
封装的意义1：
在设计类的时候，属性和行为写一起，表现事物
语法：class 类名{访问权限： 属性/行为}；
设计一个圆类
//圆周率
const double PI = 3.14；
class Circle
{
//访问权限
public:
//属性
int r;//半径
//行为
double calZC(){
return 2*PI*r;
}
Circle c ;//对象
c.r = 10;
c.calZC（）；
}
封装的意义2：
将属性和行为加以权限控制
访问权限有3种
1.public：公共权限
成员 类内可以访问，类外可以
2.protected：保护权限
成员 类内可以访问，类外不可以
3.private：私有权限
成员 类内可以访问，类外不可以
4.1.2 struct 和 class区别
在c++中，struct和class的唯一区别：
默认访问权限不同
- struct 默认权限 公共
- class 默认权限 私有
class C1
{
int a;//私有
}；
struct C2 {
int a ;//公共
}
4.1.3 成员属性设置为 私有
- 优点1：：将所有的属性设置成私有，可以自己控制读写权限
- 优点2：对于写权限，可以检测数据的有效性
4.2 对象的初始化和释放
4.2.1 构造函数和析构函数
对象的初始化和释放是2个非常重要的安全问题。
对象没用初始状态，其后果是未知的
使用完对象没释放，也会造成安全难问题
- 构造函数：创建对象时，初始化属性
- 析构函数：销毁对象时，释放资源
2个函数都是系统自动调用！
构造函数语法：类名(){ }
1.构造函数没有返回值，也不写void
2.函数名和类名相同
3.构造函数有参数，可以函数重载
4.创建对象时，自动调用一次构造函数
析构函数语法：
1.析构函数没有返回值，也不写void
2.析构函数与类名相同，在名称前加上~
3.析构函数没用参数，无法重载
4.对象销毁前会自动调用一次析构函数
Class p{
//构造函数
p(){ }
//析构函数
~p(){
}
};
4.2.3构造函数的分类和调用
两种分类方式：
按照参数：有参构造和无参构造
按照类型：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法
class Person {
public:
Person(){//无参构造
}
Person(int a){//有参构造
age = a；
}
//以上都是普通构造
Person(const Person &p){//拷贝构造
age = p.age;
}
private：
int age；
}
1.括号法
Person p1;
Person p2(10);
Person p3(p2);
2.显示法
Person p1;
Person p2 = Person(10);
Person p3 = Person(p2);
Person(6);//单独拿出来是 匿名对象
特点：当前行执行结束后，系统会立即回收匿名对象
注意事项：
不要利用拷贝构造函数，初始化匿名对象
Person(p3);
编译器会认为Person(p3) == Person p3;
3.隐式转换法
Person p4 = 10;//相当于 Person p4 = Person(10);
Person p5 = p4;//相当于 Person p5 = Person(p4);
4.2.3 拷贝构造函数的调用时机
class Person{
public:
Person(){
无参构造
}
Person(int a ){
有参构造
age =a;
}
Person(const Person & p){
拷贝构造
age = p.age;
}
~Person(){
析构函数
}
private:
int age;
}
三种情况：
- 使用一个已经创建完的对象来初始化一个新对象
void test(){
Person p1(20);
Person p2(p1);
}
- 值传递的方式给函数参数传值
void doWork(Person p){//这里相当于Person p = my_p
}
void test2(){
Person my_p;
doWork(my_p);
}
* 以值的方式返回局部对象
```c
Person doWork3(){
Person p;
return p;//这里执行完后会释放p，系统会拷贝一个临时p返回
}
void test(){
Person p = doWrok3();
}
4.2.4 构造函数调用规则
默认情况下，c++编辑器会给一个类添加3个函数
1.默认构造函数(无参 函数体为空)
2.默认析构函数(无参 函数体为空)
3.默认拷贝构造函数(对所有属性进行值拷贝)
构造函数规则：
- 如果用户定义了有参构造，c++编辑器不在提共默认无参构造，但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数，c++不会提供其他构造函数
Person(const Person & p){
拷贝构造
age = p.age;
}
4.2.5 深拷贝和浅拷贝
- 浅拷贝：值拷贝
- 深拷贝: 在堆区重新申请一块内存空间，进行拷贝操作
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Person
{
public:
Person()
{
cout<<"Person 默认构造函数"<<endl;
}
Person(int age,int height)
{
m_age = age;
m_height = new int(height);
cout<<"Person 有参构造函数"<<endl;
}
//浅拷贝：带来的问题就是堆区重复释放
Person(const Person &p)
{
cout<<"Person 浅拷贝构造函数调用"<<endl;
m_age = p.m_age;
m_height = p.m_height;
}
//深拷贝
Person(const Person &p)
{
m_age = p.m_age;
m_height = new int(*p.m_height);
}
~Person()
{
cout<<"Person 析构函数调用,m_height地址"<<m_height<<endl;
if(m_height != nullptr)
{
cout<<"释放 person=%p"<<this<<" m_height ="<<*m_height<<endl;
delete m_height;
m_height = nullptr;
}
}
int m_age;
int *m_height;
};
void test()
{
Person p1(18,180);
cout<<"p1 ="<< (int*)&p1 << " "<<p1.m_age<<" "<<*p1.m_height<<endl;
Person p2(p1);
cout<<"p2 ="<<(int*)&p2<< " "<<p2.m_age<<" "<<*p2.m_height<<endl;
}
int main(int argc, char** argv) {
test();
return 0;
}
总结：如果成员变量有在堆区开辟内存的，一点要自己提供拷贝构造函数，防止浅拷贝代理的堆内存重复释放问题
4.2.6 初始化列表
作用
c++提供初始化列表的语法，用来初始化属性
语法：构造函数():属性1(值1)，属性2(值2)···{}
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
class Person
{
public:
Person():m_a(10),m_b(20)
{
}
Person(int a,int b):m_a(a),m_b(b)
{
}
int m_a;
int m_b;
};
int main(int argc, char** argv) {
Person p;
cout<<p.m_a<<" "<<p.m_b<<endl;
Person p2(30,40);
cout<<p2.m_a<<" "<<p2.m_b<<endl;
return 0;
}
4.2.7 类对象作为类的成员
构造时：当其他类对象作为本类成员时，构造时先构造出其他类的对象，在构造自身
析构时：先析构自己，再析构其他类。(因为加载函数是栈的形式 后进先出)
class Phone
{
public:
Phone(string name):name(name)
{
cout<<"Phone 有参构造函数调用"<<endl;
//this.name = name;
}
~Phone()
{
cout<<"Phone 析构函数调用"<<endl;
}
string name;
} ;
class Person
{
public:
Person(string name,string p):name(name),p(p)
{
cout<<"Person 有参构造函数调用"<<endl;
}
~Person()
{
cout<<"Person 析构函数调用"<<endl;
}
string name;
Phone p;
};
4.2.8 静态成员
在成员函数和成员变量前面加上static关键字，成为静态成员。
静态成员分为：
- 静态成员变量
- 所有对象共享一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
class A
{
public:
static int m_a;//类内声明
}
int A::m_a = 100;//类外初始化 要去掉static
- 静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量
- 类外无法访问私有的成员函数或者变量
class Person
{
public:
static void fun()
{
cout<<"静态成员函数"<<endl;
// m_a = 1;
m_b = 2;
}
int m_a;
static int m_b;
priviate:
static void fun2()//
{
}
} ;
void test()
{
//1.通过对象调用
Person p;
p.fun();
//2.通过类名调用
Person::fun();
//私有无法访问
//Person::fun2();
}
4.3 C++的对象模型和this指针
4.3.1 成员变量和成员函数分开存储
在c++中，类内的成员变量和成员函数是分开存储的，
只有非静态成员变量才属于类的对象上
- 空对象占用内存为1个字节
c++编译器会给每个空对象分配一个字节空间，是为了区分空对象占用内存的位置。
class Person
{
} ;
void test()
{
Person p;//空对象
cout<<sizeof(p)<<endl;
}
- 只有非静态成员变量才属于类的对象上
class Person
{
int a;//非静态成员变量 属于类的对象 此时p的内存为4 个字节
static int b;//静态成员变量 不属于类对象上
void fun();//非静态成员函数 不属于类对象上
static void fun2();//静态成员函数 不属于类对象上
} ;
void test()
{
Person p;
cout<<sizeof(p)<<endl;
}
4.3.2 this指针的概念
this指针指向被调用的成员函数所属的对象
谁调用this，this就指向哪个对象
this是隐含在非静态成员函数内的一种指针
this指针的用途：
- 当形参和成员变量同名时，可以用this指针来区分
- 在类的非静态成员函数中返回对象本身，可以用return *this
class Person
{
public:
Person(int age)
{
this->age = age;
}
//这里要返回Person&，如果返回Person，系统会创建一个临时变量返回
Person& addAge(Person &p)
{
this->age += p.age;
//this指向的是p2的指针，而*this指向的是p2对象本身
return *this;
}
int age;
} ;
this指向的是p2的指针，而*this指向的是p2对象本身
4.3.3 空指针访问成员函数
c++中空指针也是可以调用成员函数的，
如果要用到this指针，要加以判断，保证代码的健壮性
class Person
{
public:
void showName()
{
cout<<"this is Person class"<<endl;
}
void showAge()
{
if(this == NULL)//增加健壮性
return;
cout<<"age = "<<this->age<<endl;//p == null 这里直接访问会崩溃
}
int age;
};
int main(int argc, char** argv) {
Person *p =NULL;
p->showName();
p->showAge();
return 0;
}
4.3.4 const修饰成员函数
常函数
- 成员函数后加const关键字，称为常函数
- 常函数内不可以修改成员属性
- 成员函数加上关键字mutable后，在常函数中就可以修改
常对象：
- 声明对象前加const称为常对象
- 常对象只能调用常函数（因为普通函数可以改成员变量，常对象不允许修改成员变量）
class Person
{
public:
//常函数
//在成员函数后面加const，修饰的是this指向，让指针指向的值也不可修改，这里 this = const Person * const this
void showPerson() const
{
//this = (Person * const this) 的本质是 指针常量，，指针的指向是不可以修改，指向的内容可变
//this->m_a = 100;不允许改变
this->m_b =100;
}
void fun()
{
//这里面可以修改成员变量的值，如 m_a =10;
}
int m_a;
mutable int m_b;//mutable变量，即使在常函数中，也能修改值
};
//常对象
void test()
{
const Person p ;//对象面前加const，成为常对象
//p.m_a = 100; 常对象不允许改任何值
p.m_b = 100;
//常对象只能调用常函数
p.showPerson();
//p.fun();//常对象不可以调用普通成员函数，因为普通成员函数可以修改成员变量，常对象又不允许修改
}
4.4 友元
作用：
让一个函数或者类访问另一个类中的私有成员
友元的关键字friend
友元的三种实现：
- 全局函数做友元
class MyHome
{
//全局函数做友元
friend void goodGay(MyHome &m);
public:
MyHome():m_livingRoom("客厅"),m_bedRoom("卧室")
{
}
string m_livingRoom;//客厅
private:
string m_bedRoom;//卧室
} ;
//全局函数
void goodGay(MyHome &m)//这里相当于 MyHome *const m = &mh;
{
cout<<"好基友正在访问:"<<m.m_livingRoom<<endl;
cout<<"好基友正在访问:"<<m.m_bedRoom;
}
int main(int argc, char** argv) {
MyHome mh;
goodGay(mh);
return 0;
}
- 类做友元
class Home
{
public:
friend class GoodGay;
Home():m_livingRoom("客厅"), m_bedRoom("卧室")
{
}
public:
string m_livingRoom;
private:
string m_bedRoom;
};
class GoodGay
{
public:
GoodGay()
{
h = new Home;
}
void visit()
{
cout<<"好基友正在访问:"<< h->m_livingRoom<<endl;
cout<<"好基友正在访问:"<< h->m_bedRoom<<endl;
}
private:
Home *h;
};
- 成员函数做友元
class GoodGay;
class Home
{
//成员函数做友元
friend void GoodGay::visit();
public:
Home():m_livingRoom("客厅"), m_bedRoom("卧室")
{
}
public:
string m_livingRoom;
private:
string m_bedRoom;
};
class GoodGay
{
public:
GoodGay()
{
h = new Home;
}
void visit()
{
cout<<"好基友正在访问:"<< h->m_livingRoom<<endl;
cout<<"好基友正在访问:"<< h->m_bedRoom<<endl;
}
private:
Home *h;
};
void test()
{
GoodGay g;
g.visit();
}
4.5 重载
ps:运算符重载跳过
4.6 继承
继承的好处
减少重复的代码
4.6.1 继承的基本语法
语法：
class 子类：继承方式 父类
子类也称为派生类
父类也成为基类
class BaspePage
{
public:
void header()
{
cout<<"首页 公开课 登录 注册"<<endl;
}
void footer()
{
cout<<"帮助中心、加入我们"<<endl;
}
} ;
class Jave : public BaspePage
{
public:
void content()
{
cout<<"这是 JAVA 教程"<<endl;
}
};
int main(int argc, char** argv) {
Jave j;
j.header();
j.content();
j.footer();
return 0;
}
4.6.2 继承的方式
继承的方式一共有三种：
- 公共继承
- 保护继承
- 私有继承
class Father
{
public:
Father():a(1),b(1),c(1)
{
}
public:
int a;
protected:
int b;
private:
int c;
};
class Son1:public Father
{
public:
void fun()
{
a= 10;
b= 20;
//c= 30;
}
};
void test01()
{
Son1 s;
s.a = 100;
//s.b = 50; 保护权限类外无法访问
}
4.6.3 继承中的对象模型
问题：从父类继承过来的成员，哪些属于子类对象中？
私有成员也会被子类继承，只是被编译器隐藏了，无法访问
class Base
{
public:
int a;
protected:
int b;
private:
int c;//私有成员也会被子类继承，只是被编译器隐藏了，无法访问
};
class Son:private Base
{
public:
int d;
};
int main(int argc, char** argv) {
Son s;
cout<<sizeof(s)<<endl;//size = 16
return 0;
}
4.6.4 继承中构造和析构的顺序
子类继承父类后，当创建子类对象时，也会调用父类的构造。
先构造父类，在构造子类，析构相反：先析构子类，再析构父类
class Base
{
public:
Base()
{
std::cout<<"Base 的默认构造函数"<<endl;
}
~Base()
{
std::cout<<"Base 的析构函数"<<endl;
}
};
class Son: public Base
{
public:
Son()
{
std::cout<<"Son 的默认构造函数"<<endl;
}
~Son()
{
std::cout<<"Son 的析构函数"<<endl;
}
};
void test()
{
Son s;
}
4.6.5 继承中同名成员的处理方式
问题：当子类与父类出现同名成员，如何通过子类对象，访问子类或者父类的同名数据呢？
- 访问子类 同名成员，直接访问即可
- 访问父类 同名成员，需要加作用域
总结：
- 1.子类对象可以直接访问到子类中的同名成员
- 2.子类对象加作用域可以访问到父类同名成员
- 3.当子类和父类拥有同名的成员函数时，子类会隐藏父类中所有的同名函数，需要加作用域才可以访问父类的同名函数
class Base
{
public:
Base()
{
m_a = 100;
}
void fun()
{
cout<<"Base - fun()"<<endl;
}
void fun(int a)
{
cout<<"Base - fun(int a)"<<endl;
}
int m_a;
};
class Son : public Base
{
public:
Son()
{
m_a = 200;
}
void fun()
{
cout<<"Son - fun()"<<endl;
}
int m_a;
};
void test()
{
Son s;
cout<<"Son 下的 m_a = "<<s.m_a<<endl;
//通过子类对象访问父类中同名成员，需要加作用域Base
cout<<"Base 下的 m_a = "<<s.Base::m_a<<endl;
}
void test2()
{
Son s;
s.fun(10);
//通过子类对象访问父类中同名成员，需要加作用域Base
s.Base::fun();
//当子类出现和父类同名的成员函数时，子类会隐藏掉父类所有的同名成员函数
//通过作用域才能访问到被隐藏的同名成员函数
s.Base::fun(10);
}
4.6.6 继承同名 静态成员 的处理方式
问题：继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致
- 访问子类同名成员，直接访问即可
- 访问父类同名成员，需要加作用域
//通过对象访问
Son s;
cout<<s.m_a<<endl;
cout<<s.Base::m_a<<endl;
//通过类名访问
cout<<Son::m_a<<endl;
//第一个：：代表通过类名方式访问，第二个：：代表访问父类作用域下
cout<<Son::Base::m_a<<endl;
总结：同名静态成员的处理方式和非静态的完全一致，只不过有2种访问方式(通过对象和通过类名)
4.6.7 多继承语法
c++中运行一个类继承多个类
语法：class 子类：继承方式 父类 1，继承方式 父类 2 ···
多继承可能会引发父类中有同名成员出现，需要加作用域区分
c++开发中不建议用多继承
class A
{
public:
A():m_a(100)
{
}
int m_a;
};
class B
{
public:
B():m_a(200)
{
}
int m_a;
};
class C : public A, public B
{
public:
C()
{
m_c = 300;
}
int m_c;
};
int main(int argc, char** argv) {
C c;
//当父类出现同名成员，需要加作用域区分
cout<<c.A::m_a<<" "<<c.B::m_a<<" "<<c.m_c<<endl;
return 0;
}
4.6.8 菱形继承
概念：
2个子类继承同一个父类
又有某个类统计继承2个子类
这种继承被称为菱形继承，或者钻石继承
class Animal
{
public:
int m_Age;
};
//继承前面加virtual关键字，变为虚继承
//此时公共父类Animal称为虚基类
class Sheep : virtual public Animal{};//羊
class Camel : virtual public Animal{};//骆驼
class Alpaca : public Sheep , public Camel{};//羊驼
int main() {
Alpaca a;
a.Sheep::m_Age = 100;
a.Camel::m_Age = 200;
cout<<"a.Sheep::m_Age ="<<a.Sheep::m_Age<<endl;
cout<<"a.Camel::m_Age ="<<a.Camel::m_Age<<endl;
cout<<"am_Age ="<<a.m_Age<<endl;//三个打印都是200，数据只有一份
return 0;
}
总结：
- 菱形继承带来主要问题是 子类继承多份相同的数据，导致资源浪费。
- 利用 虚继承 解决菱形继承问题
- 虚继承的本质是继承指针，通过指针去访问同一份数据(m_Age)
4.7 多态
多态是C++面向对象的三大特性之一
4.7.1 多态的基本概念
多态分为2类：
- 静态多态：函数重载和运算符重载 属于静态多态，复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态的区别：
- 静态多态的函数地址早绑定 - 编译阶段确定函数地址
- 动态多态的函数地址晚绑定 - 运行阶段确定函数地址
静态多态
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(int argc, char** argv) {
test();//输出结果：动物在说话
return 0;
}
动态多态
class Animal
{
public:
//加上virtual，变成虚函数，就可以晚绑定 ，子类的函数可加virtual 或者不加
virtual void speak()
{
cout<<"动物在说话"<<endl;
}
} ;
重写： 函数返回值 参数列表完全相同
重载：函数参数列表不同，返回值相同
总结：
动态多态的满足条件
- 1.有继承关系
- 2.子类重写父类的虚函数
动态多态的使用
父类的指针或者引用，执行子类对象
class A
{
public:
int fun(){}
}
这里 sizeof(A)= 1
class A
{
public:
virtual int fun(){}
}
这里 sizeof(A)= 4,因为加上 virtual ，fun就变成了一个指针(指针都是4个字节)vfptr:虚函数指针
4.7.2 多态案例-计算器
普通代码实现计算器
//普通代码实现计算器
class NomalCal
{
public:
int getResutl(int oper)
{
switch(oper)
{
case '+' :
return m_a + m_b;
break;
case '-' :
return m_a - m_b;
break;
case '*' :
return m_a * m_b;
break;
//如果想扩展功能：除法，需要修改源码
//开发中提倡开闭原则：对扩展进行开放，对修改进行关闭
default:
return 0;
}
}
int m_a;
int m_b;
} ;
void test1()
{
NomalCal nc;
nc.m_a = 10;
nc.m_b = 10;
cout<<nc.m_a<< " + " <<nc.m_b<<" = "<<nc.getResutl('+')<<endl;
}
多态实现计算器
//多态实现
class BaseCal
{
public:
virtual int getResult(){return 0;}
int m_a;
int m_b;
} ;
class AddCal : public BaseCal
{
int getResult()
{
return m_a+m_b;
}
};
有其他功能继续添加：比如减法
void test2()
{
//多态使用条件：父类指针或者引用指向之类对象
BaseCal *bc = new AddCal;
bc->m_a = 20;
bc->m_b = 10;
cout<<bc->m_a<< " + " <<bc->m_b<<" = "<<bc->getResult()<<endl;
delete bc;//记得释放
}
多态的优点：
- 代码结构清晰
- 可读性强
- 利于前期和后期的扩展以及维护，符合开闭原则
4.7.3 纯虚函数和抽象类
在多态中，通常父类中的虚函数是毫无意义的，主要调用子类的重写的函数。
因此可以把虚函数改为纯虚函数
语法：virtual 返回值类型 函数名(参数列表) = 0
当类中只要有1个纯虚函数，也把类称为抽象类
抽象类的特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类
class Base//抽象类：类中只要有一个纯虚函数
{
public:
//纯虚函数
virtual void fun() = 0;
} ;
class Son : public Base
{
public:
virtual void fun(){}
};
4.7.4 多态案例2-制作饮品
1.茶的抽象类
class AbsDrinKing
{
public:
//1.煮水
virtual void boil() = 0;
//2.冲泡
virtual void brew() = 0;
//3.倒入杯中
virtual void pourInCup() = 0;
//4.加入辅料
virtual void putSomething() = 0;
void makeDrink()
{
boil();
brew();
pourInCup();
putSomething();
}
};
2.做咖啡
class CofferDrink : public AbsDrinKing
{
//1.煮水
virtual void boil()
{
cout<<"煮咖啡"<<endl;
};
//2.冲泡
virtual void brew()
{
cout<<"泡咖啡"<<endl;
}
//3.倒入杯中
virtual void pourInCup()
{
cout<<"把咖啡倒入杯中"<<endl;
}
//4.加入辅料
virtual void putSomething()
{
cout<<"加入糖"<<endl;
}
};
3.做奶茶同理
省略···
4.制作函数
void doWork(AbsDringKing *abs)
{
abs->makeDrink();
}
4.7.5 虚析构和纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。
解决方式：将父类的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象的问题
- 都需要有具体的函数实现
虚析构和纯虚析构的区别：
- 如果是纯虚析构，则该类属于抽象类，无法实例化对象，而虚析构可以！
虚析构语法：
virtual 类名(){ }
纯虚析构语法:
virtual 类名() = 0;
类外还要写实现
类名：：~类名(){ }
可能出现内存泄漏
解决办法：
1.父类析构函数加上virtual，变成虚析构
class Animal
{
public:
Animal(){cout<<"Animal 构造函数调用"<<endl;}
virtual ~Animal(){cout<<"Animal 虚析构函数调用"<<endl;}//虚析构
virtual void speak() = 0;
};
2.纯虚析构
class Animal
{
public:
Animal(){cout<<"Animal 构造函数调用"<<endl;}
virtual ~Animal() = 0;//纯虚析构
virtual void speak() = 0;
};
Animal::~ Animal()
{
//如果父类也申请的堆区内存，可以在这里释放
cout<<"Animal 纯虚析构函数调用"<<endl;
}
总结：
- 1.虚析构和纯虚析构是用来解决 通过父类指针 释放子类对象的情况
- 2.如果子类中没有堆区数据，可以不写虚析构或者纯虚析构
- 3.拥有纯虚函数的类也属于抽象类
4.7.6 多态案例3-电脑组装
//抽象零件
//1.抽象CPU
class CPU
{
public:
virtual void cal() = 0;
};
//2.抽象显卡
class VideoCard
{
public:
virtual void display() = 0;
};
//3.抽象内存
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;
cout<<"Computer 构造函数"<<endl;
}
~ 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;
}
cout<<"Computer 析构函数 释放资源"<<endl;
}
void doWork()
{
//父类指针调用子类对象
m_cpu->cal();
m_vc->display();
m_mem->storage();
}
private:
CPU *m_cpu;
VideoCard *m_vc;
Memory *m_mem;
};
//intel 电脑
class IntelCPU : public CPU
{
public:
void cal(){cout<<"Intel cpu 工作了"<<endl;}
};
class IntelVideoCard : public VideoCard
{
public:
void display(){cout<<"Intel 显卡 工作了"<<endl;;}
};
class IntelMemory : public Memory
{
public:
void storage(){cout<<"Intel 内存 工作了"<<endl;}
};
//苹果电脑省略***
void test()
{
//第一台电脑
IntelCPU * ic = new IntelCPU;
IntelVideoCard *ivc = new IntelVideoCard;
IntelMemory *imem = new IntelMemory;
Computer *com1 = new Computer(ic,ivc,imem);
com1->doWork();
delete com1;
}
int main(int argc, char** argv) {
test();
return 0;
}
5.文件操作
文件类型分为2类：
1.文本文件：文本以ASCII码形式存储在计算机中
2.二进制文件：文本以二进制形式存储在计算机中
头文件：<fstream>
操作文件的三大类：
1.ofstream：写操作
2.ifstream：读操作
3.fstream：读写操作
5.1文本文件
5.1.1 写文件
写文件步骤：
1.包含头文件
#include <fstream>
2.创建流对象
ofstream ofs;
3.打开文件
ofs.open("文件路径"，打开方式)
4.写数据
ofs<<"数据"；
5.关闭文件
ofs.close();
文件的打开方式：
| 打开方式 | 解释 |
|---|---|
| ios::in | 读 |
| ios::out | 写 |
| ios::ate | 初始位置：文件尾 |
| ios::app | 追加方式写文件 |
| ios::trunc | 如果文件存在，先删除 再创建 |
| ios::binary | 二进制形式 |
//文本文件 写文件
void test()
{
ofstream ofs;
ofs.open("test.txt",ios::out);
ofs<<"张三 18";
ofs.close();
}
5.1.2 读文件
读文件步骤：
1.包含头文件
#include <fstream>
2.创建流对象
ifstream ifs;
3.打开文件
ifs.open("文件路径"，打开方式)
4.写数据
四种方式读取；
5.关闭文件
ifs.close();
void test()
{
ifstream ifs;
ifs.open("test.txt",ios::in);
if(!ifs.is_open())
{
cout<<"文件打开失败"<<endl;
return;
}
//方式1：读数据
// char buf[1024] = {0};
// while(ifs >> buf)
// {
// cout<<buf<<endl;
// }
//方式2：读数据
// char buf[1024] = {0};
// while(ifs.getline(buf,sizeof(buf)))
// {
// cout<<buf<<endl;
// }
//方式3：读数据
// string buf;
// while(getline(ifs,buf))
// {
// cout<<buf<<endl;
// }
//方式4：读数据
char c;
while((c = ifs.get())!=EOF)
{
cout<<c;
}
ifs.close();
}
5.2 二进制文件
以二进制的方式对文件进行读写操作，
打开方式要指定为ios::binary
5.2.1 二进制方式写文件
class Person
{
public:
char m_Name[64];
int m_age;
} ;
void test()
{
//1.引入头文件 #include <fstream>
//2.创建流对象
ofstream ofs;//或者ofs("person.txt",ios::out|ios::binary);
//3.打开文件
ofs.open("person.txt",ios::out|ios::binary);
//4.写文件
Person p = {"张三",18};
ofs.write((const char*)&p,sizeof(Person));
//5.关闭文件
ofs.close();
}
5.2.2 二进制方式读文件
二进制方式读文件主要利用流对象的成员函数read
函数原型：istream& read(char *buffer,int len);
class Person
{
public:
char m_Name[64];
int m_age;
} ;
void test()
{
//1.引入头文件
//2.创建流对象
ifstream ifs;
//3.打开文件
ifs.open("person.txt",ios::in);
if(!ifs.is_open())
{
cout<<"文件打开失败！"<<endl;
return;
}
// 4.读文件
Person p;
ifs.read((char *)&p,sizeof(Person));
cout<<p.m_age<<" "<<p.m_Name<<endl;
}
继续当一名咸鱼(￣︶￣)!
网友评论