2024年C C++最新C++（12）—(1)，2024火爆全网系列

最新推荐文章于 2024-10-20 20:14:58 发布

2401_84978559

最新推荐文章于 2024-10-20 20:14:58 发布

阅读量745

点赞数 18

分类专栏：程序员文章标签： c语言 c++ 学习

本文链接：https://blog.csdn.net/2401_84978559/article/details/138779659

版权

程序员专栏收录该内容

39 篇文章 0 订阅

订阅专栏

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

public:
Base(int data = 10) :ma(data)
{ cout << “Base” << endl; }
//虚析构函数
~Base()
{
cout << “~Base” << endl;
}
void show() { cout << “Base::show()” << endl; }
void show(int) { cout << “Base::show(int)” << endl; }
private:
int ma;
};
class Derive : public Base
{
public:
Derive(int data = 20) :Base(data), mb(data)
{
cout << “Derive” << endl;
}
//基类的析构函数是虚函数，那么派生类的析构函数自动成为虚函数
~Derive()
{
cout << “Derive” << endl;
}
void show() { cout << “Derive::show” << endl; }
private:
int mb;
};
int main()
{
Base *p = new Derive(10);
delete p;
p->show();
return 0;
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/20200813121034250.png#pic_center)  
 运行的结果和我们预期的有点差别，我们会发现派生类的析构函数没有调用，因为析构的时候，如果Base里面析构函数不是虚函数，那么识别的就是Base的析构函数，如果是虚函数，那么发生动态绑定，识别的是Derive类型，调用也是Derive类型的虚函数表  
 **构造函数和静态方法都不可以定义成虚函数  
 构造函数中（调用任何函数，都是静态绑定的）调用虚函数，也不会发生动态绑定  
 基类的指针（引用）指向堆上new出来的派生类对象的时候，delete 怕（基类的指针），他调用析构函数的时候，必须发生动态绑定，否则会导致派生类的析构函数无法调用  
 （重点）动态绑定必须由指针/引用变量调用虚函数**


### 纯虚函数和抽象类


我们先来问几个问题：  
 如何解释多态？  
 静态（编译时期）的多态：函数重载、模板（函数模板和类模板）  
 动态（运行时期）的多态  
 在继承结构中，基类指针（引用）指向派生类对象，通过该指（引用）调用同名覆盖方法（虚函数）基类指针指向哪个派生类对象，就会调用哪个派生类对象的覆盖方法，称为多态。  
 多态底层是通过动态绑定实现的


继承的好处：  
 1、可以做代码复用  
 2、可以在基类中给所有派生类提供统一的虚函数接口，让派生类进行重写，然后可以使用多态  
 纯虚函数、抽象类  
 含有纯虚成员方法的类叫做抽象类  
 我们做个练习

/*
纯虚函数、抽象类
含有纯虚成员方法的类叫做抽象类

定义Animal的初衷并不是让animal可以初始化某个实体类型
1、string _name 让所有的动物实体类可以通过继承Animal直接复用该属性
2、给所有派生类保留统一的覆盖/重写接口

抽象类不能实例化对象，但是可以定义指针和引用变量
*/
class Animal
{
public:
Animal(string name) :_name(name) {}
virtual void bark() = 0;
protected:
string _name;
};
class Cat :public Animal
{
public:
Cat(string name) :Animal(name) {}
void bark()
{
cout << _name << “i am a Cat” << endl;
}
};
class Dog :public Animal
{
public:
Dog(string name) :Animal(name) {}
void bark()
{
cout << _name << “i am a Dog” << endl;
}
};
class Pig :public Animal
{
public:
Pig(string name) :Animal(name) {}
void bark()
{
cout << _name << “i am a Pig” << endl;
}
};
void bark(Animal &p)
{
p.bark();
}

class Car
{
public:
Car(string name, double oil) :_name(name) ,_oil(oil){}
//获取汽车剩余流量还可以跑的公里数
double GetMiles()
{
// 1L 10kile * oil
return _oil * this -> GetMilesGallon();
}
protected:
string _name;
double _oil;
virtual double GetMilesGallon() = 0;
};
class Bnze : public Car
{
public:
Bnze(string name, double oil) :Car(name,oil) {}
double GetMilesGallon() { return 20; }
};
class Audi : public Car
{
public:
Audi(string name, double oil) :Car(name, oil) {}
double GetMilesGallon() { return 15; }
};
class BMW : public Car
{
public:
BMW(string name, double oil) :Car(name, oil) {}
double GetMilesGallon() { return 10; }
};
double ShowMiles(Car &car)
{
return car.GetMiles();
}
int main()
{
Bnze c1(“奔驰”,20);
Audi c2(“奥迪”,20);
BMW c3(“宝马”,20);
int a = ShowMiles(c1);
int b = ShowMiles(c2);
int c = ShowMiles(c3);
cout << a << b << c;
Cat cat(“猫”);
Dog dog(“阿拉”);
Pig pig(“猪”);

bark(cat);
bark(dog);
bark(pig);
return 0;

}


### 关于带默认参数的虚函数

class Base
{
public:
Base()
{
cout << “Base::Base()” << endl;
clear();
}
void clear()
{
memset(this, 0, sizeof(*this));
}
virtual void show(int i = 10)
{
cout << “Base::show i:” << i << endl;
}
};
class Derive : public Base
{
public:
Derive()
{
cout << “Derive::Derive” << endl;
}
void show(int i = 20)
{
cout << “Derive::show i:” << i << endl;
}
};
int main()
{
Derive *q = new Derive();