C++核心编程之类和对象---C++面向对象的三大特性--多态

news2025/1/24 11:46:21

目录

一、多态

1. 多态的概念

2.多态的分类：

1. 静态多态：

2. 动态多态：

 3.静态多态和动态多态的区别：

4.动态多态需要满足的条件：

4.1重写的概念：

4.2动态多态的调用：

二、多态

三、多态的深入剖析

四、利用多态写一个模拟计算器案例

1.普通方式写一个模拟计算器

2.利用多态的方式写一个计算器

五、纯虚函数和抽象类

抽象类特点：

六、利用多态的抽象类写一个饮品制作流程的案例

七、纯析构和纯虚析构

虚析构和纯虚析构的共性：

虚析构和纯虚析构的区别：

总结：

八、利用多态写一个组装电脑的案例

一、多态

1. 多态的概念

计算机程序运行时，相同的消息可能会送给多个不同的类别之对象，而系统可依据对象所属类别，引发对应类别的方法，而有不同的行为。简单来说，所谓多态意指相同的消息给予不同的对象会引发不同的动作。

多态也可定义为“一种将不同的特殊行为和单个泛化记号相关联的能力”。

多态可分为变量多态与函数多态。变量多态是指：基类型的变量（对于C++是引用或指针）可以被赋值基类型对象，也可以被赋值派生类型的对象。函数多态是指，相同的函数调用界面（函数名与实参表），传送给一个对象变量，可以有不同的行为，这视该对象变量所指向的对象类型而定。因此，变量多态是函数多态的基础。 

多态是c++面向对象的三大特性之一

2.多态的分类：

1. 静态多态：

      函数重载 和 运算符重载 属于静态多态，复用函数名

     静态多态（static polymorphism）：模板也允许将不同的特殊行为和单个泛化记号相关联，由于这种关联处理于编译期而非运行期，因此被称为“静态”。可以用来实现类型安全、运行高效的同质对象集合操作。C++STL不采用动态多态来实现就是个例子。

  • 函数重载（Function Overloading）

  • 运算符重载（Operator Overloading）

  • 带变量的宏多态（macro polymorphism）

  • 非参数化多态或译作特设多态（Ad-hoc polymorphism）：

  • 参数化多态（Parametric polymorphism）：把类型作为参数的多态。在面向对象程序设计中，这被称作泛型编程。

2. 动态多态：

    派生类 和 虚函数 实现运行时多态

   动态多态（dynamic polymorphism）:通过类继承机制和虚函数机制生效于运行期。可以优雅地处理异质对象集合，只要其共同的基类定义了虚函数的接口。也被称为子类型多态（Subtype polymorphism）或包含多态（inclusion polymorphism）。在面向对象程序设计中，这被直接称为多态。

对于C++语言，带变量的宏和函数重载（function overload）机制也允许将不同的特殊行为和单个泛化记号相关联。然而，习惯上并不将这种函数多态（function polymorphism）、宏多态（macro polymorphism）展现出来的行为称为多态（或静态多态），否则就连C语言也具有宏多态了。谈及多态时，默认就是指动态多态，而静态多态则是指基于模板的多态。

 3.静态多态和动态多态的区别：

        1. 静态多态的函数地址早绑定，编译阶段确定函数地址

        2. 动态多态的函数地址晚绑定，运行阶段确定函数地址

4.动态多态需要满足的条件：

        1.有继承关系

        2.子类中重写父类的虚函数（子类中写不写virtual都可以）

4.1重写的概念：

        函数返回值类型  函数名  参数列表都完全相同。

        注意：与函数重载要区分。

4.2动态多态的调用：

        父类的指针或引用  执行子类对象

二、多态

示例：

#include<iostream>

using namespace std;

// 多态

 

// 动态多态的满足条件

// 1. 有继承关系

// 2. 子类要重写父类的虚函数

 

// 动态多态的使用

// 父类的指针或引用  指向子类对象

 

// 动物类

class Animal

{

public:

    // 虚函数

    virtual void speak()

    {

        cout<<"动物在说话"<<endl;

    }

};

 

// 猫类

class Cat:public Animal

{

public:

    // 重写  函数返回值类型  函数名 参数列表要   完全相同

    void speak()

    {

        cout<<"猫在说话"<<endl;

    }

};

 

// 狗类

class Dog:public Animal

{

public:

    void speak()

    {

        cout<<"狗在说话"<<endl;

    }

};

 

// 执行说话的函数

void dospeak(Animal &animal) // Animal & animal  =  cat;

{

    // 地址早绑定  在编译阶段确定函数地址

 

    // 如果要执行猫说话，那么这个函数地址就不能提前绑定

    // 需要在运行阶段进行绑定，地址晚绑定

    animal.speak();

}

 

// c++允许父类和子类的转化

void test01()

{

    Cat cat;

    // cat.speak();

    dospeak(cat);  // 父类的引用，接收的是子类的对象

 

    Dog dog;

    dospeak(dog);

}

 

int main()

{

    test01();

    return 0;

}

没写 virtual 之前是地址早绑定

写入虚函数后，地址晚绑定运行结果：

 

三、多态的深入剖析

图解示例：

示例：

#include<iostream>

using namespace std;

// 多态的底层逻辑



// 动物类

class Animal

{

public:

    // 虚函数

    void speak()

    {

        cout << "动物在说话" << endl;

    }

};



// 猫类

class Cat :public Animal

{

public:

    // 重写  函数返回值类型  函数名 参数列表要   完全相同

    void speak()

    {

        cout << "猫在说话" << endl;

    }

};



// 狗类

class Dog :public Animal

{

public:

    void speak()

    {

        cout << "狗在说话" << endl;

    }

};



// 执行说话的函数

void dospeak(Animal& animal)

{

    // 地址早绑定  在编译阶段确定函数地址

    // 如果要执行猫说话，那么这个函数地址就不能提前绑定

    // 需要在运行阶段进行绑定，地址晚绑定

    animal.speak();

}



// c++允许父类和子类的转化

void test01()

{

    Cat cat;

    // cat.speak();

    dospeak(cat);  // 父类的引用，接收的是子类的对象



    Dog dog;

    dospeak(dog);

}



void test02()

{

        cout << "Animal 类的大小:" << sizeof(Animal) << endl;

}

int main()

{

    test01();

    test02();

    return 0;

}

通过命令提示符查看

加入虚函数后

子类在没有重写的时候

子类重写虚函数后

没加virtual的类的大小，相当于空类，大小是1

变为虚函数后的类的大小为8/4（看你的编译器是多少位的），类的大小是一个指针的大小

关于命令提示符查看类可查询上一篇文章：命令提示符查看类

四、利用多态写一个模拟计算器案例

多态的优点：

  • 代码组织结构清晰
  • 可读性强
  • 利于前期和后期的扩展及维护

1.普通方式写一个模拟计算器

示例1：

#include<iostream>

using namespace std;

// 分别利用普通写法和多态的技术实现计算器的功能

 

// 普通的写法

class Calculator

{

public:

    int get_result(string oper)

    {

        if(oper == "+")

            return m_num1+m_num2;

        if(oper == "-")

            return m_num1 - m_num2;

        if(oper == "*")

            return m_num1 * m_num2;

        if(oper == "/")

            return m_num1 / m_num2;

    }

    int m_num1;

    int m_num2;

};

void test01()

{

    Calculator c;

    c.m_num1 = 40;
    
    c.m_num2 = 20;

 

    // 开闭原则，对扩展进行开放，对修改进行关闭

 

    cout<<c.m_num1<<" + "<<c.m_num2<<" = "<<c.get_result("+")<<endl;

    cout<<c.m_num1<<" - "<<c.m_num2<<" = "<<c.get_result("-")<<endl;

    cout<<c.m_num1<<" * "<<c.m_num2<<" = "<<c.get_result("*")<<endl;

    cout<<c.m_num1<<" / "<<c.m_num2<<" = "<<c.get_result("/")<<endl;

}

int main()

{

    test01();

    return 0;

}

运行结果：

2.利用多态的方式写一个计算器

示例2：

#include<iostream>

using namespace std;

// 利用多态实现计算器

class Abstract_Calculator

{

public:

    virtual int get_result()

    {

        return 0;

    }
    
    int num1;

    int num2;

};

 

// 设计一个加法计算器的类

class Add_Calculator:public Abstract_Calculator

{

public:

    int get_result()

    {

        return num1+num2;

    }

};

// 设计一个减法计算器的类

class Sub_Calculator:public Abstract_Calculator

{

public:

    int get_result()

    {

        return num1-num2;

    }

};

// 设计一个乘法计算器的类

class Mul_Calculator:public Abstract_Calculator

{

public:

    int get_result()

    {

        return num1*num2;

    }

};

 

void test02()

{

    // 多态的使用条件

    // 父类的指针或引用指向子类对象

    // 加法运算
        
    Abstract_Calculator *abc = new Add_Calculator;

    abc->num1 = 100;

    abc->num2 = 200;

    cout<<abc->num1<<" + "<<abc->num2<<" = "<<abc->get_result()<<endl;

    // 堆区数据用完记得销毁

    delete abc;

 

    // 减法运算

    abc = new Sub_Calculator;

    abc->num1 = 200;

    abc->num2 = 100;

    cout<<abc->num1<<" - "<<abc->num2<<" = "<<abc->get_result()<<endl;

    delete abc;

 

    // 乘法运算

    abc = new Mul_Calculator;

    abc->num1 = 200;

    abc->num2 = 100;

    cout<<abc->num1<<" * "<<abc->num2<<" = "<<abc->get_result()<<endl;

    delete abc;

}

int main()

{

    test02();

    return 0;

}

运行结果：

五、纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要是调用子类的重写内容

因此可以将虚数改为纯虚数

纯虚数语法： virtual 返回值类型 函数名（参数列表） =  0 ;

当类中有了纯虚函数，这个类称为抽象类

抽象类特点：

  1. 无法实例化对象
  2. 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

示例：

#include<iostream>

using namespace std;

// 纯虚数抽象类

class Base

{

public:

    virtual void func() = 0; // 虚函数的基础上才可以等于0，纯虚函数

    // 只要有一个纯虚数,这个类称为抽象类
    
};

 

// 抽象类的子类，必须要重写父类中的纯虚函数，否则也是抽象类，无法实例化对象

class Son:public Base

{

public:

    void func()

    {

        cout<<"func函数调用"<<endl;

    }

};

void test01()

{

    // Base b; 无法实例化一个抽象类

    // new 一个也不行

    Base *base = new Son;

    base->func();

}

int main()

{

    test01();

    return 0;

}

运行结果：

六、利用多态的抽象类写一个饮品制作流程的案例

案例描述：利用多态技术，提供抽象类制作饮品基类，提供子类制作咖啡和茶叶

示例：

#include<iostream>

using namespace std;

class Abstract_Drinking

{

public:

    // 煮水

    virtual void Boil() = 0;

    // 冲泡

    virtual void Brew() = 0;

    // 倒入杯中

    virtual void Pour_Cup() = 0;

    // 加入辅助佐料

    virtual void Put_something() = 0;

    // 制作饮品

    void make_drink()

    {

        Boil();

        Brew();

        Pour_Cup();

        Put_something();

    }

};

 

// 具体的制作

// 咖啡

class Coffee:public Abstract_Drinking

{

public:

    // 煮水

    virtual void Boil()

    {

             cout<<"煮矿泉水"<<endl;

    }

    // 冲泡

    virtual void Brew()

    {

        cout<<"冲泡咖啡"<<endl;

    }

    // 倒入杯中

    virtual void Pour_Cup()

    {

        cout<<"倒入杯中"<<endl;

    }

    // 加入辅助佐料

    virtual void Put_something()

    {

        cout<<"加入糖和牛奶"<<endl;

    }

};

 

// 茶

class Tea:public Abstract_Drinking

{

public:

    // 煮水

    virtual void Boil()

    {

             cout<<"煮矿泉水"<<endl;

    }

    // 冲泡

    virtual void Brew()

    {

        cout<<"冲泡茶叶"<<endl;

    }

    // 倒入杯中

    virtual void Pour_Cup()

    {

        cout<<"倒入杯中"<<endl;

    }

    // 加入辅助佐料

    virtual void Put_something()

    {

        cout<<"加入柠檬，枸杞"<<endl;

    }

};

 

// 制作

void do_work(Abstract_Drinking * abd)

    // Abstract_Drinking *abd = new Coffee  父类指针指向子类对象

{

    abd->make_drink();

    delete abd;// 在堆区制作完记得释放

}

 

void test01()

{

    // 制作咖啡

    do_work(new Coffee);

 

    cout<<"-------------"<<endl;

    // 制作茶

    do_work(new Tea);

}

int main()

{

    test01();

    return 0;

}

运行结果：

七、纯析构和纯虚析构

问题：多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。

解决办法：将父类中的析构函数改为**虚析构**或者**纯虚析构**

虚析构和纯虚析构的共性：

  • 可以解决父类指针释放子类对象
  • 都需要有具体的函数实现

虚析构和纯虚析构的区别：

  • 如果是纯虚析构，该对象属于抽象类，无法实现实例化对象

**虚析构语法：**

virtual ~类名（）{}

**纯虚析构语法：**

virtual ~类名（）= 0；

类名：：~类名（）{} // 类内声明，类外实现

示例：

#include<iostream>

using namespace std;

// 虚析构和纯虚析构

class Animal

{

public:

    Animal()

    {

        cout<<"Animal的构造函数的调用"<<endl;

    }

    virtual void speak() = 0;// 变为纯虚函数

 

    // 利用虚析构可以解决  父类指针释放子类对象时不干净的问题

    /*

    virtual ~Animal()

    {

        cout<<"Animal虚析构函数的调用"<<endl;

    }

    */

 

    virtual ~Animal() = 0;

    // 纯虚析构

    // 需要声明  也需要实现

    // 有了纯虚析构之后，那么这个类也属于抽象类，无法实现实例化对象

};

Animal::~Animal()

{

    cout<<"Animal纯虚析构函数的调用"<<endl;

}

 

class Cat: public Animal

{

public:

    Cat(string name)

    {

        cout<<"这是Cat的构造函数的调用"<<endl;

        this->name = new string(name);

    }

    void speak()

    {

        cout<<*name<<"小猫在说话"<<endl;

    }

    ~Cat()

    {

        if(this->name!=NULL)

        {

            cout<<"这是Cat的析构函数的调用"<<endl;

            delete this->name;

            this->name = NULL;

        }

    }

    string *name;// 创建在堆区

};

 

void test01()

{

    Animal *animal = new Cat("Tom");

    animal->speak();

    // 父类的指针在析构的时候不会调用子类的析构函数

    // 导致子类如果在堆区有数据，会出现内存泄漏的情况

    delete animal;

}

int main()

{

    test01();

    return 0;

}

运行结果：

总结：

  1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
  2. 如果子类中没有堆区数据，可以不写为虚析构或者纯虚析构
  3. 拥有纯虚析构函数的类也属于抽象类

八、利用多态写一个组装电脑的案例

案例说明：

电脑主要组成部件为CPU(用于计算)，显卡〔用于显示)，内存条〔用于存储)

将每个零件封装出抽象基类，并且提供不同的厂商生产不同的霉件，例如Intel厂商和Lenovo厂商

创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口

测试时组装三台下同的电脑进行工作

示例：

#include<iostream>

using namespace std;

 

// 抽象不同零件的类

// 计算机类

class CPU

{

public:

    // 抽象的计算函数

    virtual void calculate() = 0;

};

// 显卡类

class Video_Card

{

public:

    // 抽象的显示函数

    virtual void display() = 0;

};

// 内存条类

class Memory

{

public:

    // 抽象的存储函数

    virtual void storage() = 0;

};

 

// 提供电脑类

class Computer

{

public:

    Computer(CPU* cpu, Video_Card* vc, Memory* mem)

    {

        this->cpu = cpu;

        this->vc = vc;

        this->mem = mem;

    }

 

    // 提供工作函数

    void work()

    {

        // 让零件工作起来，调用接口

        this->cpu->calculate();

        this->vc->display();

        this->mem->storage();

    }

 

    // 提供析构函数  释放在堆区创建的三个零件

    ~Computer()

    {

        if(cpu!=NULL){

            delete cpu;

            cpu = NULL;

        }

        if(vc!=NULL){

            delete vc;

            vc = NULL;

        }

        if(mem!=NULL){

            delete mem;

            mem = NULL;

        }

}

 

private:

    CPU* cpu;  // CPU的零件指针

    Video_Card* vc;  // 显卡的零件指针

    Memory* mem;  // 内存条的零件指针

};

 

// 具体厂商

// Intel厂商

// CPU

class Intel_CPU :public CPU

{

public:

    void calculate()

    {

        cout << "这是Intel厂商的CPU,并且开始计算了" << endl;

    }

};

// 显卡

class Intel_Video_Card :public Video_Card

{

public:

    void display()

    {

        cout << "这是Intel厂商的显卡，并且开始显示了" << endl;

    }

};

// 内存条

class Intel_Memory :public Memory

{

    void storage()
    
    {

        cout << "这是Intel厂商的内存条，并且开始存储了" << endl;

    }

};

 

 

// Lenovo厂商

// CPU

class Lenovo_CPU :public CPU

{

public:

    void calculate()

    {

        cout << "这是Lenovo厂商的CPU,并且开始计算了" << endl;

    }

};

// 显卡

class Lenovo_Video_Card :public Video_Card

{

public:

    void display()

    {

        cout << "这是Lenovo厂商的显卡，并且开始显示了" << endl;

    }

};

// 内存条

class Lenovo_Memory :public Memory

{

    void storage()

    {

        cout << "这是Lenovo厂商的内存条，并且开始存储了" << endl;

    }

};

 

 

void test01()

{

    cout<<"------------------------"<<endl;

    cout<<"第一台电脑开始工作"<<endl;
    
    // 创建第一台电脑的零件

    CPU* intel_CPU = new Intel_CPU;

    Video_Card* intel_videocard = new Intel_Video_Card;

    Memory* intel_memory = new Intel_Memory;

    // 创建电脑零件的时候时在堆区创建的

 

    // 创建第一台电脑

    Computer* computer1 = new Computer(intel_CPU, intel_videocard, intel_memory);

    computer1->work();

    delete computer1;

 

    cout<<"-----------------------"<<endl;

    cout<<"第二台电脑开始工作"<<endl;

    // 组装第二台电脑

    Computer* computer2 = new Computer(new Lenovo_CPU, new Lenovo_Video_Card, new Lenovo_Memory);

    computer2->work();

    delete computer2;

 

    cout<<"-----------------------"<<endl;

    cout<<"第三台电脑开始工作"<<endl;

    // 组装第三台电脑

    Computer* computer3 = new Computer(new Lenovo_CPU, new Intel_Video_Card, new Lenovo_Memory);

    computer3->work();

    delete computer3;

}

int main()

{

    test01();

    return 0;

}

运行结果：

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

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

相关文章

快速排序学习笔记

快速排序学习笔记

代码框架 // 在数组nums将下标从left到right中进行从小到大排序// 原理是先将一个元素排好序&#xff0c;然后将其他的元素排好序void sort(int[] nums, int left, int right) {if (left > right) {return;}// 对数组nums[left,right]进行切分&#xff0c;使得nums[left,p-1…
阅读更多...
Pandoc：markdown转word

Pandoc：markdown转word

简介&#xff1a;Pandoc是由John MacFarlane开发的标记语言转换工具&#xff0c;可实现不同标记语言间的格式转换&#xff0c;堪称该领域中的“瑞士军刀”。Pandoc使用Haskell语言编写&#xff0c;以命令行形式实现与用户的交互&#xff0c;可支持多种操作系统&#xff1b;Pand…
阅读更多...
A connection was successfully established with the server but then an error

A connection was successfully established with the server but then an error

在使用EFCore生成数据库的时候&#xff0c;报上面的错误&#xff01; 解决方法&#xff1a; 加&#xff08;EncryptTrue;TrustServerCertificateTrue;&#xff09;即可&#xff1a; "ConnectionStrings": { "DefaultConnection": "Data SourceLAP…
阅读更多...
大厂咋做支付系统的核对？

大厂咋做支付系统的核对？

核对是保障资金安全的重要机制。 时效角度&#xff0c;主要有&#xff1a; &#xff08;准&#xff09;实时核对 准确性不如离线核对&#xff0c;且需相应实时核对平台建设 离线核对&#xff08;如 T1 核对&#xff09; 主要问题是发现问题的时机较为后置&#xff0c;部分场景…
阅读更多...
软件测试|教你使用Python下载图片

软件测试|教你使用Python下载图片

前言 我一直觉得Windows系统默认的桌面背景不好看&#xff0c;但是自己又没有好的资源可以进行替换&#xff0c;突然我一个朋友提醒了我&#xff0c;网络上的图片这么多&#xff0c;你甚至可以每天换很多个好看的背景&#xff0c;但是如果让我手动去设置的话&#xff0c;我觉得…
阅读更多...
Consider defining a bean of type ‘XXXX‘ in your configuration.

Consider defining a bean of type ‘XXXX‘ in your configuration.

今天学习尚硅谷的SpringCloud时&#xff0c;发现支付模块无法启动&#xff0c;控制台输出下面的错误: 看起来可能是dao层没有被注入。 然后根据我已有的知识&#xff0c;我检查了注解Mapper Mapper public interface PaymentDao {public int create(Payment payment);public…
阅读更多...
Nacos下载与安装【Linux】

Nacos下载与安装【Linux】

&#x1f95a;今日鸡汤&#x1f95a; 我不是天生的王者&#xff0c;但我骨子里流动着不让我低头的血液。 ——《海贼王》 目录 &#x1f32d;1.官网下载 &#x1f37f;2.根据需求下载Linux版本 &#x1f953;3.上传到Linux &#x1f9c2;4.解压Nacos &#x1f9c8; 5.…
阅读更多...
C++力扣题目701--二叉搜索树中的插入操作

C++力扣题目701--二叉搜索树中的插入操作

给定二叉搜索树&#xff08;BST&#xff09;的根节点 root 和要插入树中的值 value &#xff0c;将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 &#xff0c;新值和原始二叉搜索树中的任意节点值都不同。 注意&#xff0c;可能存在多种有效的插入方式&a…
阅读更多...
温和去油去黑头，只需敷上一刻钟的泥膜就够了

温和去油去黑头，只需敷上一刻钟的泥膜就够了

冬季天气干燥&#xff0c;很多朋友脸部更容易出油&#xff0c;连带着黑头也变多了。这是因为干燥的环境会刺激皮脂腺分泌&#xff0c;导致皮肤油脂分泌过多&#xff0c;容易堵塞毛孔形成黑头。因此&#xff0c;在冬季特别需要注意控油去黑头的工作。 控油去黑头需要清洁毛孔&am…
阅读更多...
Sentinel微服务保护

Sentinel微服务保护

文章目录 Sentinel微服务保护1.初识Sentinel1.1.雪崩问题及解决方案1.1.1.雪崩问题1.1.2.解决方案1.1.3.总结 1.2.服务保护技术对比1.3.Sentinel介绍和安装1.3.1.初识Sentinel1.3.2.安装Sentinel 1.4.微服务整合Sentinel 2.流量控制2.1.簇点链路2.1.快速入门2.2.流控模式2.2.1.…
阅读更多...
docker应用：vocechat

docker应用：vocechat

简介&#xff1a;VoceChat是一款超轻量级的Rust聊天应用程序、API和SDK&#xff0c;优先考虑私人托管。使用VoceChat建立您自己的聊天功能&#xff01;作为一款非常好用的通讯应用程序&#xff0c;它可以让你与朋友、家人和同事进行即时消息聊天&#xff0c;支持图片视频的分享…
阅读更多...
Python相对导入和绝对导入

Python相对导入和绝对导入

目录结构&#xff1a; 在 en_de_model_CDDD.py 文件有两种导入方式可以导入utils.py&#xff0c;分别是 相对导入&#xff1a; from ...public_utils.utils import canonicalize_smiles 绝对导入&#xff1a; from public_utils.utils import canonicalize_smiles 这里推荐使…
阅读更多...
Fluent 动网格应用：2.5D 网格重构

Fluent 动网格应用：2.5D 网格重构

1 概述 2.5D 网格重构是一种快速网格重构方法&#xff0c;主要应用于涡旋压缩机等存在复杂平面运动且无法简化为二维计算的问题。 涡旋压缩机工作原理&#xff08;视频源&#xff1a;维基百科&#xff09; 适用于 2.5D 动网格的问题特点&#xff1a; 计算域几何形状为柱体类形…
阅读更多...
WorkPlus企业内部即时通信新选择，打造高效协作新格局

WorkPlus企业内部即时通信新选择，打造高效协作新格局

在企业内部&#xff0c;快速、高效的沟通与协作是推动工作进程的关键。而即时通信工具成为了企业内部沟通的重要工具。作为一款优秀的企业内部即时通信工具&#xff0c;WorkPlus通过其出色的性能和独特的功能&#xff0c;为企业打造高效协作的新格局。 为什么选择WorkPlus作为企…
阅读更多...
算法训练营Day43(背包问题）

算法训练营Day43(背包问题）

1049. 最后一块石头的重量 II 1049. 最后一块石头的重量 II - 力扣&#xff08;LeetCode&#xff09; class Solution {public int lastStoneWeightII(int[] stones) {int sum 0;for(int num:stones){sumnum;}int target sum/2;//1 dp数组&#xff1a;背包容量为j&#xf…
阅读更多...
MATLAB Deep learning

MATLAB Deep learning

文章目录 Chapter 1: Machine Learning存在的问题过拟合Overfitting解决过拟合 regularization and validationregularization 正则化validation 验证 机器学习的类型有监督学习分类Classification回归Regression 无监督学习聚类 强化学习 Chapter 2: Neural Network神经网络的…
阅读更多...
MySQL之多表连接查询、AS别名、扩展内容(information_schema的基本应用)

MySQL之多表连接查询、AS别名、扩展内容(information_schema的基本应用)

文章目录 前言一、引入多表连接查询二、多表连接查询案例1.准备对应的库表2.案例 三、AS别名用法示例 四、扩展内容1、information_schema的基本应用2、创建视图示例3、information_schema.tables视图的应用3.1、示例 五、show命令总结总结 前言 第三章内容主要描述了mysql使用…
阅读更多...
力扣-盛最多水的容器

力扣-盛最多水的容器

11.盛最多水的容器 给定一个长度为 n 的整数数组 height 。有 n 条垂线&#xff0c;第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。找出其中的两条线&#xff0c;使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。 说明&#xff1a;你不能倾斜…
阅读更多...
HTML如何设置背景图片？有几种设置背景图片的办法？

HTML如何设置背景图片？有几种设置背景图片的办法？

我们在编辑网页时&#xff0c;如果觉得网页过于单调&#xff0c;这时便可以加上一张自己喜欢的背景图。这篇文章中&#xff0c;W3Cschool 小编给大家介绍下 HTML 中如何设置背景图片&#xff0c;分别有哪几种设置背景图片的方法。 方法一、HTML中设置背景图片 HTML中的<bo…
阅读更多...
vue.js-3

vue.js-3

#前后端交互
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023