＜C++＞多态

news2024/11/16 7:55:23

文章目录

  • 1. 概念
  • 2. 多态的定义和实现
    • 2.1 多态的构成条件
    • 2.2 虚函数
    • 2.3 虚函数的重写
    • 2.4 虚函数重写的两个例外：
    • 2.5 C++11 override和final
    • 2.6 重载、覆盖(重写)、隐藏(重定义)的对比
  • 3. 抽象类
    • 3.1 概念
    • 3.2 接口继承和实现继承
  • 3. 多态的原理
    • 3.1 虚函数表
    • 3.2 多态的原理
    • 3.3 动态绑定与静态绑定
  • 4. 单继承和多继承关系的虚函数表
    • 4.1 单继承中的虚函数表
    • 4.2 多继承中的虚函数表
  • 5. 细节补充

1. 概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同类型的对象去完成时会产生出不同的状态

举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2. 多态的定义和实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：

  1. 必须通过基类的指针或者引用调用虚函数（即可以接收基类对象也可以接收派生类对象）
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

image-20220813195519389

2.2 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

2.3 虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数接口被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用*/
/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{ p.BuyTicket(); }
int main()
{
    Person ps;
    Student st;
    Func(ps);
    Func(st);
    return 0;
}

2.4 虚函数重写的两个例外：

  1. 协变(基类与派生类虚函数返回值类型不同)
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解）
class A{};
class B : public A {};

class Person {
public:
	virtual A* f() {return new A;}
};
class Student : public Person {
public:
	virtual B* f() {return new B;}
};
  1. 析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor
class Person {
public:
	virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
    Person* p1 = new Person;
    Person* p2 = new Student;//希望它调用Student的析构函数
    delete p1;
    delete p2;
    return 0;
}

2.5 C++11 override和final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

  1. final：修饰虚函数，表示该虚函数不能再被重写 ；修饰类，表示该类不能被继承
class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	virtual void Drive() {cout << "Benz" << endl;}
};
  1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
class Car{
public:
	virtual void Drive(){}
};
class Benz :public Car {
public:
	virtual void Drive() override {cout << "Benz-舒适" << endl;}
}

2.6 重载、覆盖(重写)、隐藏(重定义)的对比

image-20220813204642101

3. 抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），**抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。**纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承

class Car
{
public:
	virtual void Drive() = 0;//实现没有意义，因为没有对象会调用它
};
class Benz :public Car
{
public:
    virtual void Drive()
    {
    	cout << "Benz" << endl;
    }
};
class BMW :public Car
{
public:
    virtual void Drive()
    {
    	cout << "BMW" << endl;
    }
};
void Test()
{
    Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBMW = new BMW;
    pBMW->Drive();
}

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数

3. 多态的原理

3.1 虚函数表

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
    virtual void Func1()
    {
    	cout << "Func1()" << endl;
    }
private:
	int _b = 1;
};

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。那么派生类中这个表放了些什么呢？我们接着往下分析

image-20220814104042435

// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
    virtual void Func1()
    {
    	cout << "Base::Func1()" << endl;
    }
    virtual void Func2()
    {
    	cout << "Base::Func2()" << endl;
    }
    void Func3()
    {
    	cout << "Base::Func3()" << endl;
    }
private:
	int _b = 1;
};
class Derive : public Base
{
public:
    virtual void Func1()
    {
    	cout << "Derive::Func1()" << endl;
    }
private:
	int _d = 2;
};
int main()
{
    Base b;
    Derive d;
    return 0;
}

通过观察和测试，我们发现了以下几点问题：

  1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚
    表指针也就是存在部分的另一部分是自己的成员。
  2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法（派生类对继承类虚函数实现进行了重写），覆盖是原理层的叫法（子类的虚表，拷贝父类的虚表进行修改，覆盖重写那个虚函数）。
  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
  4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
  5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
  6. 这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的

image-20220814105423765

3.2 多态的原理

上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的Person::BuyTicket，传Student调用的是Student::BuyTicket

image-20220814105534416

  1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
  2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
  3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
  4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。思考一下为什么？首先，虚函数才能存在虚表里，虚函数覆盖才能让不同对象的虚表里存不同的函数指针。其次，用对象的指针或引用调用虚函数，才能实现不同类型对象调用不同类里的函数
  5. 再通过下面的汇编代码分析，看出多态调用：运行时决议–运行时（查虚函数表）确定调用函数的地址。普通调用：编译时决议–编译时确定调用函数的地址

image-20220814105843598

void Func(Person* p)
{
	p->BuyTicket();
}
int main()
{
    Person mike;
    Func(&mike);
    mike.BuyTicket();
    return 0;
}

// 以下汇编代码中跟这个问题不相关的都被去掉了
void Func(Person* p)
{
    ...
    p->BuyTicket();
    // p中存的是mike对象的指针，将p移动到eax中
    001940DE mov eax,dword ptr [p]
    // [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
    001940E1 mov edx,dword ptr [eax]
    // [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
    00B823EE mov eax,dword ptr [edx]
    // call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的中取找的。
    001940EA call eax
    001940EC cmp esi,esp
}

int main()
{
    ...
    // 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
    mike.BuyTicket();
    00195182 lea ecx,[mike]
    00195185 call Person::BuyTicket (01914F6h)
    ...
}

3.3 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
  3. 本小节之前买票的汇编代码很好的解释了什么是静态(编译器)绑定和动态(运行时)绑定。

4. 单继承和多继承关系的虚函数表

需要注意的是在单继承和多继承关系中，下面我们去关注的是派生类对象的虚表模型，因为基类的虚表模型前面我们已经看过了，没什么需要特别研究的

4.1 单继承中的虚函数表

class Base {
public :
    virtual void func1() { cout<<"Base::func1" <<endl;}
    virtual void func2() {cout<<"Base::func2" <<endl;}
private :
	int a;
};
class Derive :public Base {
public :
    virtual void func1() {cout<<"Derive::func1" <<endl;}
    virtual void func3() {cout<<"Derive::func3" <<endl;}
    virtual void func4() {cout<<"Derive::func4" <<endl;}
private :
    int b;
};

观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数

image-20220814182752737

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
    // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
        printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        VFPTR f = vTable[i];
        f();
    }
    cout << endl;
}
int main()
{
    Base b;
    Derive d;
    // 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr
    // 1.先取b的地址，强转成一个int*的指针
    // 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    // 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    // 4.虚表指针传递给PrintVTable进行打印虚表
    // 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。
    VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    PrintVTable(vTableb);
    VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    PrintVTable(vTabled);
    return 0;
}

image-20220814182914605

4.2 多继承中的虚函数表

class Base1 {
public:
    virtual void func1() {cout << "Base1::func1" << endl;}
    virtual void func2() {cout << "Base1::func2" << endl;}
private:
	int b1;
};

class Base2 {
public:
    virtual void func1() {cout << "Base2::func1" << endl;}
    virtual void func2() {cout << "Base2::func2" << endl;}
private:
	int b2;
};

class Derive : public Base1, public Base2 {
public:
    virtual void func1() {cout << "Derive::func1" << endl;}
    virtual void func3() {cout << "Derive::func3" << endl;}
    private:
    int d1;
};

typedef void(*VFPTR) ();

void PrintVTable(VFPTR vTable[])
{
    cout << " 虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i)
    {
        printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        VFPTR f = vTable[i];
        f();
    }
    cout << endl;
}

int main()
{
    Derive d;
    VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    PrintVTable(vTableb1);
    VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
    PrintVTable(vTableb2);
    return 0;
}

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

image-20220814183108181

5. 细节补充

先来一道恶心的题看看：

class A
{
public:
    virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}
    virtual void test(){ func();}
};
class B : public A
{
public:
	void func(int val=0){ std::cout<<"B->"<< val <<std::endl; }
};
int main(int argc ,char* argv[])
{
    B*p = new B;
    p->test();
    return 0;
}

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

正确答案：B

解析：

子类继承了test函数，所以子类指针能通过切割切片调用test(A* this)，之后调用this->func()

首先func()函数符合多态的两个条件，子类继承重写了父类的虚函数func()。覆盖重写是指：接口继承+重写函数实现（B中的func不写virtual也是虚函数，并且缺省值是用A::func()的1。之后打印B::func()的"B->"，合起来就是B->1 ）

补充概念：

  1. inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。
  2. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
  3. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
  4. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。参考本节课件内容2.4
  5. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
  6. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
  7. 什么是抽象类？抽象类的作用？答：参考（3.抽象类）。抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/71042.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

S2SH小区物业管理系统计算机专业毕业论文java毕业设计网站

S2SH小区物业管理系统计算机专业毕业论文java毕业设计网站

&#x1f496;&#x1f496;更多项目资源&#xff0c;最下方联系我们✨✨✨✨✨✨ 目录 Java项目介绍 资料获取 Java项目介绍 《S2SH小区物业管理系统》该项目采用技术&#xff1a;jsp struts2springhibernatecssjs等相关技术&#xff0c;项目含有源码、文档、配套开发软件…
阅读更多...
java EE初阶 — wait 和 notify

java EE初阶 — wait 和 notify

文章目录1.wait 和 notify1.1 wait()方法1.2 notify()方法1.3 notifyAll()方法1.wait 和 notify 线程最大的问题是抢占式指向&#xff0c;随机调度。而写代码的时候&#xff0c;确定的东西会比较好。 于是就有程序猿发明了一些办法&#xff0c;来控制线程之间的执行顺序。 虽…
阅读更多...
火山引擎 RTC 助力抖音百万并发“云侃球”

火山引擎 RTC 助力抖音百万并发“云侃球”

动手点关注干货不迷路1. 背景及技术挑战从电视看直播到手机电脑看直播&#xff0c;直播技术的发展让观众可以随时、随地观看自己喜欢的比赛&#xff0c;并且在看比赛时通过发送表情、发文字进行互动。但表情、文字承载的信息量较小、沟通效率低&#xff0c;我们无法像线下一起看…
阅读更多...
一大波节日来袭，App Store节日营销请注意！

一大波节日来袭，App Store节日营销请注意！

11 月已经过去&#xff0c;在过去的 11 月里&#xff0c;我们经历了万圣节、双 11、世界杯、感恩节、黑色星期五等非常重要的营销节点。 在新的 12 月&#xff0c;我们将迎来世界杯闭幕、双12、平安夜、圣诞节等重要营销机遇。在未来&#xff0c;我们还会迎来新春营销的重要机…
阅读更多...
图形API学习工程（29）：解决在shader文件中使用include的问题

图形API学习工程（29）：解决在shader文件中使用include的问题

工程GIT地址&#xff1a;https://gitee.com/yaksue/yaksue-graphics 无用的前言 看了下提交记录&#xff0c;这个工程上次更新已经是一年以前了。最近想想&#xff0c;还是应该回来再继续学学&#xff0c;暂且不论是否对工作有帮助&#xff0c;我在这个工程上获得的愉悦感相比…
阅读更多...
Excel 是您最容易被忽视的设计工具 设计师对世界排名第一的电子表格工具的看法——如何构建信息图表、仪表板、演示文稿等

Excel 是您最容易被忽视的设计工具 设计师对世界排名第一的电子表格工具的看法——如何构建信息图表、仪表板、演示文稿等

人们对 Excel 有很多误解。许多人认为它不过是处理临时预算的电子表格工具。或者它非常适合处理数据，但您需要像 PowerPoint 这样的单独工具才能很好地显示它。 这些误解限制了我们使用 Excel 的方式。 但 Excel 的功能远不止于此，它所需要的只是了解一些鲜为人知的功能。我…
阅读更多...
JAVA SCRIPT设计模式--创建型设计模式之工厂方法（3）

JAVA SCRIPT设计模式--创建型设计模式之工厂方法（3）

JAVA SCRIPT设计模式是本人根据GOF的设计模式写的博客记录。使用JAVA SCRIPT语言来实现主体功能&#xff0c;所以不可能像C&#xff0c;JAVA等面向对象语言一样严谨&#xff0c;大部分程序都附上了JAVA SCRIPT代码&#xff0c;代码只是实现了设计模式的主体功能&#xff0c;不代…
阅读更多...
机器学习笔记之配分函数(三)对比散度

机器学习笔记之配分函数(三)对比散度

机器学习笔记之配分函数——对比散度引言回顾&#xff1a;随机最大似然求解模型参数的过程随机最大似然的缺陷吉布斯采样的缺陷与对比散度思想对比散度名称的由来从KL\mathcal K\mathcal LKL散度的角度描述极大似然估计对比散度的本质引言 上一节介绍了随机最大似然(Stochasti…
阅读更多...
第十四届蓝桥杯集训——JavaC组第四篇——ASCII码表与Scanner扫描器

第十四届蓝桥杯集训——JavaC组第四篇——ASCII码表与Scanner扫描器

第十四届蓝桥杯集训——JavaC组第四篇——ASCII码表与Scanner扫描器 目录 第十四届蓝桥杯集训——JavaC组第四篇——ASCII码表与Scanner扫描器 ASCII码表 Scanner扫描器 1、Scanner含义 2、使用方法&#xff1a; next和nextLine的区别 next&#xff1a; nextLine&#…
阅读更多...
微服务框架 SpringCloud微服务架构 23 搜索结果处理 23.2 分页

微服务框架 SpringCloud微服务架构 23 搜索结果处理 23.2 分页

微服务框架 【SpringCloudRabbitMQDockerRedis搜索分布式&#xff0c;系统详解springcloud微服务技术栈课程|黑马程序员Java微服务】 SpringCloud微服务架构 文章目录微服务框架SpringCloud微服务架构23 搜索结果处理23.2 分页23.2.1 分页23.2.2 深度分页问题23.2.3 深度分页…
阅读更多...
Zookeeper常用命令大全之四字监控命令

Zookeeper常用命令大全之四字监控命令

文章目录四字监控命令0. 官方文档1. conf命令2. cons命令3. crst命令4. dump命令5. envi命令6. ruok命令7. stat命令8. srst命令9. wchs命令10. wchc命令(一般不用)11. wchp命令(一般不用)12. mntr命令四字监控命令 zookeeper支持某些特定的四字命令与其的交互。它们大多是查询…
阅读更多...
自媒体短视频,如何起一个让人一看就记住的昵称?看一眼就知道你的定位

自媒体短视频,如何起一个让人一看就记住的昵称?看一眼就知道你的定位

上一篇我们说了头像如何设置更吸引人&#xff0c;今天上午在我赢且力手小禾呈序里聊了一个好听好记的昵称应该是怎样的&#xff1f; 这是文字版&#xff0c;大家可以看一看。 昵称起名的方式无非几种&#xff1a; 职业加昵称&#xff0c;昵称加地点&#xff0c;昵称加领域&a…
阅读更多...
全球数据集大全之mavenanalytics学习分析世界杯数据集

全球数据集大全之mavenanalytics学习分析世界杯数据集

mavenanalytics数据集平台介绍 探索和下载由 Maven 讲师精心挑选的示例数据集。练习将您的数据分析和可视化技能应用于现实世界的数据，从航班延误和电影收视率到鲨鱼袭击和不明飞行物目击事件。 平台效果 是否支持下载 可以免费下载 https://www.mavenanalytics.io/data-p…
阅读更多...
Java基于jsp大学生收支管理系统

Java基于jsp大学生收支管理系统

随着计算机技术的飞速发展&#xff0c;计算机在系统管理中的应用越来越普及&#xff0c;利用计算机实现各个系统的管理显得越来越重要。随着人们消费水平的提高&#xff0c;消费量一直在加大 &#xff0c;可是如何能够合理的管理和记录自己的消费方向是一个很大的问题&#xff…
阅读更多...
深度学习炼丹-不平衡样本的处理

深度学习炼丹-不平衡样本的处理

前言一&#xff0c;数据层面处理方法 1.1&#xff0c;数据扩充1.2&#xff0c;数据&#xff08;重&#xff09;采样 数据采样方法总结 1.3&#xff0c;类别平衡采样 二&#xff0c;算法&#xff08;损失函数&#xff09;层面处理方法 2.1&#xff0c;Focal Loss2.2&#xff0c;…
阅读更多...
Akka 学习（三）Actor的基本使用

Akka 学习（三）Actor的基本使用

目录一 基本案例1.1 Java 版1.2 Scala版二 Actor的创建2.1 ActorRef2.2 Props2.3 ActorSelection三 Promise、Future和事件驱动的编程模型3.1 阻塞与事件驱动3.2 Future进行Actor响应3.2.1 Java版3.2.2 Scala 版3.2.3 总结3.3 成功处理3.4 失败处理3.5 恢复3.6 链式调用3.7 结果…
阅读更多...
小程序开发工具怎么使用？

小程序开发工具怎么使用？

小程序开发工具怎么用&#xff1f; 小程序开发工具分两种: 一种是微信官方提供的微信开发者工具 这个需要从事代码行业&#xff0c;职业是程序员又或者对代码知识有一定程度的人&#xff0c;才能上手使用。 另一种是第三方小程序开发平台&#xff0c;提供的小程序开发工具 …
阅读更多...
python环境、基础语法、几种常见的数据类型

python环境、基础语法、几种常见的数据类型

文章目录前言一、基本知识介绍二、举例实操以及重要知识再现(列表、元组、集合、字典)前言 一、基本知识介绍 python基础 标准库与扩展库中的对象的导入与使用&#xff1a; import 模块名&#xff08;as别名&#xff09; import numpy as np from 模块名 import 对象名&#x…
阅读更多...
程序人生：快来一起学习软件测试，一起月薪过万（测试理论基础学习）

程序人生：快来一起学习软件测试，一起月薪过万（测试理论基础学习）

测试基础 为什么要有测试呢&#xff1f;现在软件已经和人的生活息息相关了&#xff0c;所以保证软件的稳定很重要。但是所有开发出来的软件都是有缺陷的。包括代码错误&#xff0c;逻辑错误&#xff0c;设计不合理等。 测试的目的 测试的目的主要有四个点 1找到软件缺陷 2…
阅读更多...
Flink SQL增量查询Hudi表

Flink SQL增量查询Hudi表

前言 前面总结了Spark SQL增量查询Hudi表和Hive增量查询Hudi表。最近项目上也有Flink SQL增量查询Hudi表的需求&#xff0c;正好学习总结一下。 官网文档 地址&#xff1a;https://hudi.apache.org/cn/docs/querying_data#incremental-query 参数 read.start-commit 增量查…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023