2024年最新C++基础语法----多态(1)，2024年最新前端页面性能优化有哪些

Vue 编码基础

2.1.1. 组件规范

2.1.2. 模板中使用简单的表达式

2.1.3 指令都使用缩写形式

2.1.4 标签顺序保持一致

2.1.5 必须为 v-for 设置键值 key

2.1.6 v-show 与 v-if 选择

2.1.7 script 标签内部结构顺序

2.1.8 Vue Router 规范

Vue 项目目录规范

2.2.1 基础

2.2.2 使用 Vue-cli 脚手架

2.2.3 目录说明

2.2.4注释说明

2.2.5 其他

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

继承后有赋值兼容原则,父类与子类中可以写相同函数名相同类型的函数

子类的对象可以调用父类的函数也可以调用自己的,但是如果用父类的指

针指向子类的对象那么那个父类的指针只会认识父类函数,因为编译器为

了安全静态编联时将父类的函数与父类的指针绑定在了一起;此时无法得

到子类相应的函数方法;这使我们在编写程序或使用程序时很麻烦

具体问题如下代码:

#include

using namespace std;

class AA {

public:

int a=100;

int Gett() {

return a;

}

void print() {

cout << “我是爸爸” << endl;

}

};

class BB :public AA{

public:

int b=200;

int Gett() {

return b;

}

void print() {

cout << “我是儿子” << endl;

}

};

int main_01() {

AA* p;

BB q;

p = &q;

p->print();//输出我是爸爸;也就是p与AA类的函数绑定在了一起；无法对子类的成员和方法进行操作

cout << p->Gett() << endl;//输出100;

return 0;

}

也就是说,指向子类的父类指针,只调用父类里面的函数方法;

二、怎样实现多态?

===========================================================================

1.实现多态的三个先决条件

---

• 进行了类的继承；

• 子类与父类写了结构相同的函数(并且基类的函数是虚的)；

• 使用了基类指针指向了子类的对象

2.语法

---

//语法(条件1,2)：

calss A{

public:

virtual void print(){}

};

class B:public A{

public:

void print(){}

};

//语法(条件3)

int main(){

A *p;

B q;

p=&q;（基类的指针指向子类的对象）//此时便可以进行多态实现

return 0;

}

此时基类A中加virtual关键字的函数称为虚函数

如果将{}改为=0则函数print称为纯虚函数,AA类称为虚基类(或抽象类)【不可以直接定义对象】

当基类中有纯虚函数时如果继承的子类没有将纯虚函数实现,那么子类也将变为抽象类。

3.具体实例

---

战争游戏,传进去的参数没变,仅仅改变了一下基类指针的指向

就产生了不同的效果。这个案例使用zhanzheng函数作为中央大舞台

基类指针指向友军或me实现多态,同一段代码不同的人对敌人发动进攻。

//实现多态的案例;

#include

using namespace std;

class OUr {

public:

int a=15;

virtual int get() {//进行虚函数处理;仅仅将这一个函数进行了虚函数处理;

return a;//其他没有进行虚处理的函数还会有老的问题

}

void print() {

cout << “我是父亲” << endl;

}

};

class him :public OUr{

public:

int h=25;

int get() {

return h;

}

void print() {

cout << “我是 Tom” << endl;

}

};

class me :public OUr {

public:

int m=30;

int get() {

return m;

}

void print() {

cout << “我是 zsc” << endl;

}

};

class Diren {

public:

int D = 26;

int get() {

return D;

}

void print() {

cout << “我是Diren” << endl;

}

};

void zhanzheng(OUr* p, Diren& a) {

if (p->get() > a.get()) {

cout << “我们将敌人秒杀了” << endl;

}

else {

cout << “我们败北” << endl;

}

}

int main_02() {

OUr * p;

him friends;

me zsc;

Diren DDD;

p = &friends;

zhanzheng(p,DDD);

p = &zsc;

zhanzheng(p, DDD);

p->print();//打印基类的print函数；

return 0;

}

三、多态实现行为分析

============================================================================

1.函数重载、重写、重定义

---

①函数重载:

发生在一个类,名字相同参数类型或个数不同；

②函数重写:

子类继承父类,子类中写了一个与父类名称相同,参数列表也相同的函数;

剖析函数重写:

多态: 如果使用了virtual关键字,那么就构成多态；

多态在运行时根据所给的对象类型选择调用的函数;

③函数重定义：

举个例子:基类有两个打印函数print(),与print（int a）;这两个函数构成重载；

子类中定义了一个函数,名字也叫print参数无所谓,此时子类就将父类的print重定义(覆盖掉);

比如子类定义了一个print(),那么他将无法调用起来父类的print(int a),与print();

与virtual关键字无关,此时说的对象是子类的对象,virtual对应的是基类指针

⚠️重写纯虚函数可以产生多态;

⚠️重写普通函数可以产生重定义；(不加virtual关键字)重定义之后就无法再通过子类的对象调用父类的函数

2.虚析构函数与虚构造函数

---

①构造函数能不能定义成为虚的?

不能,virtual定义虚函数为了多态;

构造函数是在对象初始化期间自动调用的,不需要手动的调动更不用产生多态；

将构造函数定义为虚函数没有什么实际意义

②为什么要用虚析构函数?

我们知道virtual关键字主要实现动态绑定

如果不使用虚构造函数,在析构对象时会与调用函数时的效果一样；

只调用基类的析构函数;而此时子类未被析构会造成内存泄漏

用virtual关键字对析构函数处理,会产生多态,在运行时,根据析

构的对象是什么类的类型合理调用析构函数;

③怎么使用虚析构函数?

在析构函数面前加上virtual

具体如下：

#include

using namespace std;

class testa {

public:

testa(int a) {

this->a = a;

}

int a;

virtual ~testa(){

cout << “欧式爸爸析构函数” << endl;

}

};

class testb :public testa{

public:

testb(int b):testa(b) {

this->b = b;

}

int b;

~testb() {

cout << “欧式孩子析构函数” << endl;

}

};

void howTodel(testa *p) {

if (p != NULL) {

delete p;//delete要与new或者malloc搭配，不能直接释放编译器自动分配的内存；

}

}

int main_04() {

testa* p = new testa (1);

testa* q = new testb(1);//子类函数中有基类的属性

howTodel§;//如果不加virtual则与普通函数一样只会调基类的析构函数;

howTodel(q);//子类的对象得不到析构,可能会引发内存泄漏,解决方法就是在析构函数前加virtual；

return 0;

}

四、多态实现原理剖析

============================================================================

1.理论基础

---

c与c++语言是静态编译型语言;

在程序未运行之前编译器就将代码串联在一起（什么时候运行哪一步）;

基类指针可以指向子类对象,但是编译器进行静态编联时不清楚基类指针到底指向谁,

此时编译器判定：基类指针是基类的类型,又由于程序未运行为了安全起见编译器就

将基类指针指向了基类的对象；

动态联编:在运行时编译器根据代码运行的效果选择如何进行后续的操作;

eg:

if语句 switch语句

virtual关键字起到的作用是告诉编译器,这个函数要支持多态,不要根据他

指针的类型判断如何调用他；

2.实现原理

---

①为什么在函数声明时加了virtual会发生多态?

是在函数声明时在函数前加上的virtual 会将该函数拿到此类对应的虚函数表,

并拿一个vptr指针指向该虚函数表。

vptr指针与基类的指针指向的对象相对应;

(基类的指针指向什么类的对象, vptr指针就指向什么类的虚函数表)

而此时vptr指针与this指针相似,程序员并看不到；

所以在调用虚函数时,根据基类指针指向对象的vptr指针的类型在对

应的虚函数表中找到函数入口,由此发生多态;

②怎样证明vptr指针的存在?

设置两个相同的类,属性与方法也相同,在某个函数前加上virtual类的大小会增加4；

继续增加基类中的含有virtual函数类的大小还会不会增加？

不会,类的大小只会增加一次,增加的那一次就是将带有virtual的指针指向虚函数表,

将虚函数拿到虚函数表;再用virtual声明函数时直接将函数拿到虚函数表,所以不会再增加;

(函数平时存在代码区,不占类的大小);

具体实现方法：

#include

using namespace std;

class vvPtr1 {

public:

int a;

int b;

virtual void print() {

cout << “This. ok” << endl;

}//没有加virtual所以类的大小比属性与方法都相同的vvptr1小了4,指针的大小就是4；

Vue 编码基础

2.1.1. 组件规范

2.1.2. 模板中使用简单的表达式

2.1.3 指令都使用缩写形式

2.1.4 标签顺序保持一致

2.1.5 必须为 v-for 设置键值 key

2.1.6 v-show 与 v-if 选择

2.1.7 script 标签内部结构顺序

2.1.8 Vue Router 规范

Vue 项目目录规范

2.2.1 基础

2.2.2 使用 Vue-cli 脚手架

2.2.3 目录说明

2.2.4注释说明

2.2.5 其他

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】