先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Web前端全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024c （备注前端）
正文
============================================================================
①函数重载:
发生在一个类,名字相同参数类型或个数不同；
②函数重写:
子类继承父类,子类中写了一个与父类名称相同,参数列表也相同的函数;
剖析函数重写:
多态: 如果使用了virtual关键字,那么就构成多态；
多态在运行时根据所给的对象类型选择调用的函数;
③函数重定义：
举个例子:基类有两个打印函数print(),与print（int a）;这两个函数构成重载；
子类中定义了一个函数,名字也叫print参数无所谓,此时子类就将父类的print重定义(覆盖掉);
比如子类定义了一个print(),那么他将无法调用起来父类的print(int a),与print();
与virtual关键字无关,此时说的对象是子类的对象,virtual对应的是基类指针
⚠️重写纯虚函数可以产生多态;
⚠️重写普通函数可以产生重定义；(不加virtual关键字)重定义之后就无法再通过子类的对象调用父类的函数
①构造函数能不能定义成为虚的?
不能,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;
}
============================================================================
c与c++语言是静态编译型语言;
在程序未运行之前编译器就将代码串联在一起（什么时候运行哪一步）;
基类指针可以指向子类对象,但是编译器进行静态编联时不清楚基类指针到底指向谁,
此时编译器判定：基类指针是基类的类型,又由于程序未运行为了安全起见编译器就
将基类指针指向了基类的对象；
动态联编:在运行时编译器根据代码运行的效果选择如何进行后续的操作;
eg:
if语句 switch语句
virtual关键字起到的作用是告诉编译器,这个函数要支持多态,不要根据他
指针的类型判断如何调用他；
①为什么在函数声明时加了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；
virtual void print1() {//再增加一组virtual声明的函数,类的大小不再改变,
//更加有力的支持了vptr指针指向虚函数表
cout << “this 1” << endl;//然后完成多态,并不是对函数本身做了什么手脚
}
};
class vvPtr2 {
public:
int a1;
int c1;
void print() {
cout << “This. big ok” << endl;
}
void print1() {
cout << “this big 1” << endl;
}
};
int main_05() {
cout << “vvPrt1：” <<sizeof(vvPtr1)<<“vvPtr2：”<<sizeof(vvPtr2)<< endl;
return 0;
}
③子类的vptr指针分步初始化：
初始化子类对象时,首先构造基类的属性与方法,初始化子类对象时在基类
中调用能产生多态的函数时会产生调用基类的函数效果;也就是在初始化
对象期间并不产生多态,原因就是子类的vptr指针分步初始化,子类对象构
造完毕,指针初始化完成
初始化完基类属性,再初始化子类的属性,此时再调用多态函数会产生子类的函数效果
④子类与父类的步长问题;
当子类相比父类没有增加新的属性时,两种类的指针步长相同;
否则不相同,并且是子类的步长要大于父类的步长；
如果子类父类指针步长不同当定义一个对象数组时,用父类指针移动对象会出现问题;
这两个问题的实现方法如下：
#include
using namespace std;
class testparent {
public:
testparent() {
// print();
}
virtual void print() {
cout << “我是爸爸” << endl;
}
};
class testchild :public testparent{
public:
int a;
testchild() {
// print();
}
virtual void print() {
cout << “我是儿子” << endl;
}
};
int main_06() {
testchild pp;//构造时输出我是爸爸，我是儿子；
//所以在构造自己的基类属性时调用了基类的print在构造自己属性时调用了自己的print;
testchild test[3];//构造完后,子类的vptr指针指向自己的虚函数表;
testparent* p;
testchild* q;
p = test;
q = test;
p->print();
q->print();
p++;//如果子类没有计入新的属性,则步长相同,不会有什么问题;
q++;//如果子类中加入新的属性,再进行指针的位移,会出错，
p->print();//错的原因是基类指针位移的长度达不到子类下一对象的开始
q->print();
return 0;
}
============================================================================
virtual 返回类型 函数名(参数列表)=0;
有纯虚函数定义的类叫抽象类,并且抽象类不可以定义对象;
如果子类不将继承来的纯虚函数实例化；那么子类也将是抽象类;
抽象类中的函数可以作为接口使用,可以将多继承
中的基类变成抽象类将其内部的纯虚函数作为接口使用
多继承容易产生二义性,给代码维护带来灾难性的影响，
有纯虚函数类就被归为抽象类,该类不可以拿去定义对象;
而产生二义性就是因为子类不知道怎样调用父类里面的数据成员；
抽象类不定义对象,也就不用设置数据成员所以
将基类设置成抽象类避免了二义性的产生;
在抽象类中设置函数接口有利于后来写的类对抽象类函数进行实例化并投入使用实现相应的功能；
但这个不叫多态；
抽象类的使用场景：
#include
using namespace std;
class J1 {
public:
virtual int add(int a, int b) = 0;
virtual void print()=0;
};
class J2 {
public:
virtual int mutily(int a, int b) = 0;
virtual void print() = 0;
};
class child1:public J1,public J2 {
public:
virtual int add(int a, int b) {
return a + b;
}
virtual int mutily(int a, int b) {
return a * b;
}
virtual void print() {
cout << “哈哈哈” << endl;
}
};
int main() {
J1* p;
J2* q;
child1 C;
p = &C;//通过不同的抽像基类指向相同的子类可以实现不同的功能；
q = &C;//也可以通过不同的子类赋给基类,产生不同的效果;
cout << p->add(1, 2) << " " << q->mutily(2, 3) << endl;
p->print();
q->print();
return 0;
}
1.不能建立对象；
2.不能作为函数参数类型；
3.不能作为返回值类型；
4.能建立该类型的指针；
5.能声明抽象类的引用
总结
前端资料汇总
-
框架原理真的深入某一部分具体的代码和实现方式时，要多注意到细节，不要只能写出一个框架。
-
算法方面很薄弱的，最好多刷一刷，不然影响你的工资和成功率😯
-
在投递简历之前，最好通过各种渠道找到公司内部的人，先提前了解业务，也可以帮助后期优秀 offer 的决策。
-
要勇于说不，对于某些 offer 待遇不满意、业务不喜欢，应该相信自己，不要因为当下没有更好的 offer 而投降，一份工作短则一年长则 N 年，为了幸福生活要慎重选择！！！
喜欢这篇文章文章的小伙伴们点赞+转发支持，你们的支持是我最大的动力！
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
3.不能作为返回值类型；
4.能建立该类型的指针；
5.能声明抽象类的引用
总结
前端资料汇总
-
框架原理真的深入某一部分具体的代码和实现方式时，要多注意到细节，不要只能写出一个框架。
-
算法方面很薄弱的，最好多刷一刷，不然影响你的工资和成功率😯
-
在投递简历之前，最好通过各种渠道找到公司内部的人，先提前了解业务，也可以帮助后期优秀 offer 的决策。
-
要勇于说不，对于某些 offer 待遇不满意、业务不喜欢，应该相信自己，不要因为当下没有更好的 offer 而投降，一份工作短则一年长则 N 年，为了幸福生活要慎重选择！！！
喜欢这篇文章文章的小伙伴们点赞+转发支持，你们的支持是我最大的动力！
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注前端）
[外链图片转存中…(img-KbRD3vYA-1713652144339)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
310
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
