【C++入门到精通】C++入门 —— 多态（抽象类和虚函数的魅力）

news2024/9/22 2:22:45

在这里插入图片描述

阅读导航

  • 前言
  • 一、多态的概念
    • 1. 概念
    • 2. 多态的特点
  • 二、多态的定义及实现
    • 1. 多态的构成条件
    • 2. 虚函数
    • 3. 虚函数的重写
      • ⭕虚函数重写的两个例外
        • 1.协变(基类与派生类虚函数返回值类型不同)
        • 2.析构函数的重写(基类与派生类析构函数的名字不同)
    • 4. override 和 final（C++11 ）
      • override
      • final
    • 5. 重载、覆盖(重写)、隐藏(重定义)的对比
      • 1. 重载
      • 2. 覆盖（也称为重写）
      • 3. 隐藏（也称为重定义）
  • 三、抽象类
    • 1. 抽象类的概念
    • 2. 接口继承和实现继承
      • -- 接口继承
      • -- 实现继承
      • -- 适用类型
  • 四、多态的原理
    • 1. 虚函数表
    • 2. 动态绑定与静态绑定
      • 动态绑定
      • 静态绑定
    • 3. 多态的原理
  • 五、单继承和多继承关系中的虚函数表
    • 1. 单继承中的虚函数表
    • 2. 多继承中的虚函数表
  • 六、多态总结
  • 温馨提示

前言

前面我们讲了C语言的基础知识，也了解了一些数据结构，并且讲了有关C++的命名空间的一些知识点以及关于C++的缺省参数、函数重载，引用 和 内联函数也认识了什么是类和对象以及怎么去new一个 ‘对象’ ，也了解了C++中的模版，以及学习了几个STL的结构也相信大家都掌握的不错，接下来博主将会带领大家继续学习有关C++比较重要的知识点—— 多态（抽象类和虚函数的魅力）。下面话不多说坐稳扶好咱们要开车了😍

一、多态的概念

1. 概念

多态是面向对象编程中的一个重要概念，指的是同一个消息被不同类型的对象接收时产生不同的行为。通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

⭕多态的核心思想是通过基类指针或引用来调用派生类的方法，在运行时确定实际调用的方法。这种动态绑定的特性使得代码更加灵活，能够适应不同的对象和场景。

2. 多态的特点

  1. 多态性通过继承和虚函数的机制来实现。
  2. 多态性在运行时动态地确定调用的函数，而不是在编译时静态地确定。
  3. 多态性可以让相同的代码适用于不同类型的对象，提高代码的可重用性和扩展性。
  4. 多态性能够进行方法重写，不同的派生类可以根据自身的需求提供不同的方法实现。

二、多态的定义及实现

1. 多态的构成条件

实现多态性的关键是满足以下两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

🚨虚函数：通过在基类中使用 virtual 关键字声明函数为虚函数，可以实现动态绑定，使得在运行时选择调用实际对象的方法。（下面会有概念及定义）

虚函数允许通过基类指针或引用调用派生类的方法，而在运行时动态地确定实际调用的函数。当通过基类指针或引用调用虚函数时，编译器会根据实际对象的类型来调用相应的派生类函数。

以下是实现多态性的典型代码结构：

class Base {
public:
    virtual void polymorphicFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    virtual void polymorphicFunction() {
        // 派生类重写基类虚函数的实现
    }
};

基类 Base 声明了一个虚函数 polymorphicFunction()，派生类 Derived 重写了这个虚函数。通过基类指针或引用来调用该虚函数时，实际执行的是派生类中的函数实现。

总结起来，多态的构成条件是基于继承关系和虚函数的使用。满足这两个条件后，就可以通过基类的指针或引用调用派生类的函数，实现多态性的效果。

下面这个图片模拟了一个简单的多态的定义以及实现的过程，实现了“不同人群，买了不同的票”
在这里插入图片描述

2. 虚函数

⭕虚函数：即被virtual修饰的类成员函数称为虚函数。例如：

class Base {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

3. 虚函数的重写

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

class Derived : public Base {
public:
    virtual void myFunction() {
        // 派生类重写基类虚函数的实现
    }
};

⭕虚函数重写的两个例外

1.协变(基类与派生类虚函数返回值类型不同)

🚩派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

协变的实现和使用需要满足以下条件:

  1. 继承关系：
    协变是基于继承关系的特性，需要存在基类和派生类。派生类继承了基类的属性和方法。

  2. 虚函数：
    必须在基类中将要协变的虚函数声明为虚函数，并在派生类中重新定义（重写）该虚函数。基类中的虚函数返回类型应该是指向某种类型的指针或引用，而派生类中的重写函数的返回类型可以是指向派生类类型的指针或引用。

下面是一个示例来说明协变的使用方法：

class Base {
public:
    virtual Base* createInstance() {
        return new Base();
    }
};

class Derived : public Base {
public:
    Derived* createInstance() override {
        return new Derived();
    }
};

在上述示例中，Base 类声明了一个虚函数 createInstance()，该函数返回类型为 Base*，即指向 Base 类对象的指针。在派生类 Derived 中重写了这个函数，将返回类型修改为 Derived*，即指向 Derived 类对象的指针。

通过协变，派生类 Derived 可以返回比基类 Base 更具体的类型，即 Derived*。这样，在使用基类指针调用派生类的虚函数时，实际会返回派生类的对象指针。

🚨注意

  • 协变只适用于指针或引用类型的返回值，而不适用于值类型。
  • 派生类重写函数的返回类型必须在基类函数返回类型的派生类型层次结构中。

2.析构函数的重写(基类与派生类析构函数的名字不同)

🍪如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor

以下是一个示例演示如何在派生类中重写基类的析构函数：

class Base {
public:
    virtual ~Base() {
        // 基类析构函数的实现
    }
};

class Derived : public Base {
public:
    ~Derived() override {
        // 派生类析构函数的实现
    }
};

在上述示例中，基类 Base 声明了一个虚析构函数 ~Base()。派生类 Derived 重写了基类的虚析构函数，使用 ~Derived() 来重新定义析构函数的实现。

🚨注意：

  • 虚析构函数只需要在基类中声明，不需要在派生类中显式声明为虚函数。
  • 为了确保正确的析构顺序，派生类的析构函数可以在末尾隐式调用基类的析构函数，不需要显式调用。

⭕重写基类的析构函数在处理继承关系和多态性时非常重要，它能够确保在销毁派生类对象时，正确地调用相应的析构函数，避免资源泄漏和未定义行为。

4. override 和 final（C++11 ）

override 和 final 都是 C++11 中引入的关键字，用于标识和修饰虚函数的行为。

override

override 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

示例：

class Base {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    void myFunction() override {
        // 派生类重写基类虚函数的实现
    }
};

在上述示例中，派生类 Derived 使用 override 关键字表明它重写了基类 Base 的虚函数 myFunction()。如果在派生类中意外地使用了错误的函数签名（参数列表或返回类型不匹配），编译器会发出错误提示。

final

final 用于标识类、成员函数或虚函数，表示它们被声明为最终版本，禁止在派生类中进一步继承或重写。

示例：

class Base final {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    void myFunction() /* override 不可使用 */ {
        // 派生类重写基类虚函数的实现
    }
};

在上述示例中，基类 Base 使用 final 关键字标识它是最终类，不允许被继续派生。同时，派生类 Derived 中的 myFunction() 不能使用 override 关键字进行标识，因为基类已经被声明为最终类。

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

在这里插入图片描述

1. 重载

重载是指在同一个作用域内，根据函数的参数列表的不同，可以定义多个具有相同名称但参数不同的函数。重载函数可以有不同的返回类型，但不能仅仅通过返回类型的不同来进行重载。

示例：

void myFunction(int x) {
    // 函数实现
}

void myFunction(double x) {
    // 函数实现
}

在上述示例中，myFunction 函数被重载了，分别接受一个 int 类型和一个 double 类型的参数。

2. 覆盖（也称为重写）

覆盖是指派生类中重新定义（重写）基类的虚函数，以实现多态性。派生类中的虚函数必须与基类的虚函数具有相同的函数签名（包括参数列表和返回类型），并使用 override 关键字进行标识。

示例：

class Base {
public:
    virtual void myFunction() {
        // 基类虚函数的默认实现
    }
};

class Derived : public Base {
public:
    void myFunction() override {
        // 派生类重写基类虚函数的实现
    }
};

在上述示例中，派生类 Derived 重写了基类 Base 的虚函数 myFunction()，并使用 override 关键字进行标识。

3. 隐藏（也称为重定义）

隐藏是指派生类中定义了与基类中同名的非虚函数或静态函数，从而隐藏了基类中的同名函数。隐藏函数不具有多态性，调用时会根据对象的静态类型来确定调用的函数。

示例：

class Base {
public:
    void myFunction() {
        // 基类函数的实现
    }
};

class Derived : public Base {
public:
    void myFunction() {
        // 派生类函数的实现
    }
};

在上述示例中，派生类 Derived 定义了与基类 Base 同名的函数 myFunction()，从而隐藏了基类的同名函数。

总结：

  • 重载是指在同一个作用域内定义多个具有相同名称但参数列表不同的函数。
  • 覆盖是指派生类中重新定义（重写）基类的虚函数，以实现多态性。
  • 隐藏是指派生类中定义了与基类中同名的非虚函数或静态函数，从而隐藏了基类中的同名函数。

三、抽象类

1. 抽象类的概念

抽象类是一种特殊的类，它不能实例化对象，只能作为其他类的基类。抽象类用于定义一组相关的类的共同接口，它包含纯虚函数和非纯虚函数。

可以通过在类中声明纯虚函数来创建抽象类。纯虚函数是一个在基类中声明但没有具体实现的虚函数，它通过在函数声明后添加 “= 0” 来指示。

抽象类的主要目的是定义一组规范和约束，要求派生类实现纯虚函数，以便在派生类中实现具体的功能。

以下是一个抽象类的示例：

class AbstractClass {
public:
    virtual void pureVirtualFunction() const = 0;
    virtual void virtualFunction() const {
        // 可选的虚函数实现
    }
    void regularFunction() const {
        // 非虚函数的实现
    }
};

在上述示例中，AbstractClass 是一个抽象类。它包含了纯虚函数 pureVirtualFunction()，该函数没有具体实现，需要在派生类中进行实现。同时，它还包含了一个可选的虚函数 virtualFunction() 和一个非虚函数 regularFunction()。

抽象类具有以下特点：

  • 不能创建抽象类的对象，只能通过派生出的非抽象子类来创建对象。
  • 子类必须实现抽象类中的纯虚函数，否则子类也成为抽象类。
  • 抽象类可以包含非纯虚函数和数据成员。
  • 抽象类的指针可以用于引用或指向派生类的对象。

抽象类提供了一个接口的定义和封装，强制要求派生类实现接口中的方法。这种设计方式有助于实现多态性和代码的可扩展性，提高代码的模块化和重用性。

2. 接口继承和实现继承

– 接口继承

  • 接口继承关注的是类与类之间的协议或合约。一个类可以通过继承一个或多个接口来表明它具有实现这些接口所定义的方法和行为。
  • 接口（Interface）定义了一组纯虚函数（只有声明没有实现），表示了一种约定或契约，派生类必须实现这些纯虚函数。
  • 接口继承使得类之间的关系更加松耦合，可以实现更好的代码复用和扩展性。

– 实现继承

  • 实现继承关注的是类与类之间的具体的实现关系。一个类可以通过继承的方式获取另一个类的属性和方法的实现。
  • 在实现继承中，子类（派生类）继承父类（基类）的成员变量和成员方法，并可以通过继承的方式进行扩展或修改。
  • 实现继承可以扩展基类的功能，实现代码重用，但也可能导致类之间的紧密耦合。

– 适用类型

  • 当关注类之间的协议和约定，希望实现一种行为的一致性时，可以选择接口继承。
  • 当一个类希望获取另一个类的具体实现，并在此基础上进行扩展时，可以选择实现继承。

四、多态的原理

1. 虚函数表

我们首先来看一道题目：sizeof(Base)是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

在这里插入图片描述

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

针对上面的代码我们做出以下改造

  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. 虚函数存在哪的？
    答：虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。（虚表存的是虚函数指针，不是虚函数，另外对象中存的不是虚表，存的是虚表指针）

2. 动态绑定与静态绑定

动态绑定

  • 动态绑定是在运行时确定函数、方法或操作要与调用者绑定的过程。
  • 动态绑定适用于虚函数和纯虚函数，通过基类的指针或引用来调用派生类的虚函数。
  • 在动态绑定中，根据对象的实际类型（而不是引用或指针的类型）来确定要调用的函数。这意味着在运行时才能确定函数的具体绑定。
  • 动态绑定通过虚函数表和虚函数指针来实现。编译器会查找虚函数表，并根据对象的实际类型找到对应的虚函数进行调用。

⭕动态绑定实现了多态性，使得通过基类的指针或引用调用派生类的虚函数时，能够在运行时根据对象的实际类型决定要调用的函数，从而实现了多态行为。

静态绑定

  • 静态绑定是在编译时确定函数、方法或操作要与调用者绑定的过程。
  • 在静态绑定中，根据引用或指针的声明类型来确定要调用的函数、方法或操作。
  • 静态绑定适用于非虚函数、静态函数和全局函数。编译器在编译阶段就能够确定调用哪个函数。
  • 静态绑定通常比动态绑定更快，因为在编译时已经决定了函数调用的路径。

🚨注意：静态绑定和动态绑定是相对的概念，多态性是建立在动态绑定的基础上的。在面向对象编程中，静态绑定主要用于非虚函数或静态函数，而动态绑定主要用于虚函数。

3. 多态的原理

🔴多态的原理主要基于两个关键的机制：虚函数和动态绑定。

🚩多态的实现步骤

  1. 定义一个基类，并在其中声明一个或多个虚函数。
  2. 派生类继承基类，并可以选择重写基类中的虚函数。
  3. 创建基类的指针或引用，并指向派生类的对象。
  4. 通过基类的指针或引用调用虚函数。
  5. 运行时系统根据对象的实际类型确定要调用的虚函数，实现动态绑定，即根据对象的真正类型来调用正确的函数。

需要注意的是，多态性只适用于通过指针或引用调用虚函数的情况。当直接通过对象调用函数时，编译器在编译时就能够确定调用哪个函数，不会发生动态绑定。

⭕多态通过虚函数和动态绑定实现，允许我们以统一的方式处理不同类型的对象，并在运行时根据对象的实际类型调用适当的虚函数，从而实现了面向对象编程中的多态性。

五、单继承和多继承关系中的虚函数表

1. 单继承中的虚函数表

✅**在单继承关系中，每个类只有一个直接基类，因此虚函数表的实现相对简单。**每个类的虚函数表存储了该类及其直接基类中的所有虚函数的地址。当通过对象的指针或引用调用虚函数时，编译器会使用对象的虚函数指针（vptr）来查找虚函数表，并根据对象的实际类型确定要调用的具体虚函数。

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)(); // 定义函数指针类型 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

        f(); // 通过调用函数指针 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;
}

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
在这里插入图片描述
这里有两篇文章推荐大家看一下
C++ 虚函数表解析
C++ 对象的内存布局

六、多态总结

  1. 多态性通过虚函数和动态绑定实现。虚函数是在基类中声明的带有关键字 virtual 的函数，它可以在派生类中重写（覆盖）。动态绑定是根据对象的实际类型来确定要调用的虚函数。

  2. 多态允许通过基类的指针或引用操作不同类型的对象，而无需关心对象的具体类型。这提高了代码的可扩展性和可维护性。

  3. 多态遵循面向对象编程的封装和抽象原则，能够隐藏对象的具体实现细节，将关注点放在接口和行为上。

  4. 在单继承关系中，每个类只有一个直接基类，虚函数表的实现相对简单，直接存储类及其直接基类的虚函数地址。通过对象的指针或引用调用虚函数时，根据对象的虚函数指针和虚函数表确定要调用的函数。

  5. 在多继承关系中，一个类可以有多个直接基类，可能涉及虚基类表和虚函数表指针数组的实现。虚基类表用于存储虚基类的相关信息，虚函数表指针数组在派生类的虚函数表中包含指向每个基类虚函数表的指针。

  6. 多态性只适用于通过指针或引用调用虚函数的情况。直接通过对象调用函数时，编译器在编译时就能够确定调用哪个函数，不会发生动态绑定。

温馨提示

感谢您对博主文章的关注与支持！另外，我计划在未来的更新中持续探讨与本文相关的内容，会为您带来更多关于C++以及编程技术问题的深入解析、应用案例和趣味玩法等。请继续关注博主的更新，不要错过任何精彩内容！

再次感谢您的支持和关注。期待与您建立更紧密的互动，共同探索C++、算法和编程的奥秘。祝您生活愉快，排便顺畅！
在这里插入图片描述

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

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

相关文章

SLAM从入门到精通（开始篇）

SLAM从入门到精通（开始篇）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 很多同学喜欢学习linux&#xff0c;但是他们只是把linux当成是一个嵌入式技术在学习&#xff0c;而不是当成工具在使用。平时&#xff0c;要么是自…
阅读更多...
appium+python自动化测试

appium+python自动化测试

获取APP的包名 1、aapt即Android Asset Packaging Tool&#xff0c;在SDK的build-tools目录下。该工具可以查看apk包名和launcherActivity 2、在android-sdk里面双击SDK-manager,下载buidl-tools 3、勾选build-tools&#xff0c;随便选一个版本&#xff0c;我这里选的是24的版…
阅读更多...
YOLOv5、v8改进：CrissCrossAttention注意力机制

YOLOv5、v8改进：CrissCrossAttention注意力机制

目录 1.简介 2. yolov5添加方法&#xff1a; 2.1common.py构建CrissCrossAttention模块 2.2yolo.py中注册 CrissCrossAttention模块 2.3修改yaml文件。 1.简介 这是ICCV2019的用于语义分割的论文&#xff0c;可以说和CVPR2019的DANet遥相呼应。 和DANet一样&#xff0c;…
阅读更多...
DBeaver的安装和使用：windows版

DBeaver的安装和使用：windows版

DBeaver官网下载地址&#xff1a;https://dbeaver.io/download/ 下载完成后&#xff0c; 进入傻瓜式安装&#xff1a; 这里会进入重复界面&#xff0c;一样点击下一步即可 选择安装目录&#xff0c;尽量不要选C盘&#xff0c; 我的电脑只有c盘&#xff0c; 没办法 等待安装完成…
阅读更多...
linux操作系统的权限的深入学习（未完）

linux操作系统的权限的深入学习（未完）

1.Linux权限的概念 Linux下有两种用户&#xff1a;超级用户&#xff08;root&#xff09;、普通用户。 超级用户&#xff1a;可以再linux系统下做任何事情&#xff0c;不受限制 普通用户&#xff1a;在linux下做有限的事情。 超级用户的命令提示符是“#”&#xff0c;普通用户…
阅读更多...
MVSNet 和 PatchMatchNet 的DTU数据集 几个不同之处 一定要注意

MVSNet 和 PatchMatchNet 的DTU数据集 几个不同之处 一定要注意

文章目录 1 测试集 数据加载不同2 训练集 数量 分辨率不同 1 测试集 数据加载不同 1.MVSNet 的DTU测试数据集和PatchmatchNet测试数据集不一样&#xff1b; 区别在于数据加载&#xff0c;前者 cams文件最后是最小深度和间隔&#xff0c;后者是最小深度和最大深度。 2 训练集 …
阅读更多...
layui框架学习（41：表单模块）

layui框架学习（41：表单模块）

之前的文章《layui框架学习》14-16中介绍了通过预设类及部分layui属性设置表单的外观样式&#xff0c;layui中还提供有表单模块以对表单元素进行各类动态化渲染和相关操作&#xff0c;本文学习并记录表单模块form的常用属性、函数及事件的用法&#xff08;如果内容已在之前文章…
阅读更多...
时序预测 | MATLAB实现SSA-XGBoost(麻雀算法优化极限梯度提升树)时间序列预测

时序预测 | MATLAB实现SSA-XGBoost(麻雀算法优化极限梯度提升树)时间序列预测

时序预测 | MATLAB实现SSA-XGBoost(麻雀算法优化极限梯度提升树)时间序列预测 目录 时序预测 | MATLAB实现SSA-XGBoost(麻雀算法优化极限梯度提升树)时间序列预测预测效果基本介绍模型描述程序设计参考资料 预测效果 基本介绍 Matlab实现SSA-XGBoost时间序列预测&#xff0c;麻…
阅读更多...
VS警告 C4819 该文件包含不能在当前代码页(936)中表示的字符。请将该文件保存为 Unicode 格式以防止数据丢失

VS警告 C4819 该文件包含不能在当前代码页(936)中表示的字符。请将该文件保存为 Unicode 格式以防止数据丢失

1、问题 Microsoft visual studio 2019跑仿真的时候出现该警告&#xff0c;在高级保存选项设置编码为Unicode(UTF-8 无签名)还是会有该警告。 2、解决方法 右键项目&#xff0c;打开属性设置&#xff0c;选中&#xff1a;工程 -> 右键选择"属性" -> C/C ->…
阅读更多...
JSON文件读写教程【jsoncpp源码编译】【结尾附三方库下载链接】

JSON文件读写教程【jsoncpp源码编译】【结尾附三方库下载链接】

目录 1 数据下载(jsoncpp源码)2 文件编译3 测试用例4 下载链接：内容： JSON文件的读取与保存可以使用jsoncpp库来实现，这里介绍该库的下载及编译方法。 1 数据下载(jsoncpp源码) 数据下载：Github地址 图1 github源码示意图 2 文件编译 2.1 点击Download ZIP，下载源码。 …
阅读更多...
大数据分析与AI在农业领域的应用

大数据分析与AI在农业领域的应用

文章目录 数据采集与监测数据分析与预测个性化管理与优化决策支持系统结合物联网技术优势与前景 &#x1f388;个人主页&#xff1a;程序员 小侯 &#x1f390;CSDN新晋作者 &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏 ✨收录专栏&#xff1a;Java知识介绍 ✨文章内容&a…
阅读更多...
使用ChatGPT给Python代码写单元测试

使用ChatGPT给Python代码写单元测试

先写一个简单的python函数&#xff0c;找chatgpt写单元测试&#xff1a; 有一个python函数&#xff0c;请帮忙写单元测试&#xff0c;函数长这样&#xff1a; def test2(a: list, b: list) -> float:"""计算两个坐标的距离:param a list 格式如&#xff1a…
阅读更多...
记一次蓝屏日志

记一次蓝屏日志

记一次Win 蓝屏日志&#xff1a; &#x1f4f2;引&#xff1a; 虽然说&#xff0c;我是一个在职两年半的程序员&#xff0c;但是对于这个问题其实也和大部分人一样&#xff0c;一脸懵逼&#x1f916; 那是一个风和日丽的早上&#xff0c;w开开心心去上班摸鱼&#x1f41f;&a…
阅读更多...
LiteOS qemu realview-pbx-a9 环境搭建与运行

LiteOS qemu realview-pbx-a9 环境搭建与运行

前言 最近打算移植搭建 一些常见的 RTOS 的 qemu 开发学习环境&#xff0c;当前 RT-Thread、FreeRTOS 已经成功运行 qemu&#xff0c;LiteOS 初步验证可以正常 运行 qemu realview-pbx-a9&#xff0c;这里做个记录 首先学习或者研究 RTOS&#xff0c;只是看内核源码&#xff0…
阅读更多...
SNN论文总结

SNN论文总结

Is SNN a great work ? Is SNN a convolutional work ? ANN的量化在SNN中是怎么体现的&#xff0c;和threshold有关系吗&#xff0c;threshold可训练和这个有关吗&#xff08;应该无关&#xff09; 解决过发放不发放的问题。 Intuation SNN编码方式 Image to spike patter…
阅读更多...
性能优化维度

性能优化维度

CPU 首先检查 cpu&#xff0c;cpu 使用率要提升而不是降低。其次CPU 空闲并不一定是没事做&#xff0c;也有可能是锁或者外部资源瓶颈。常用top、vmstat命令查看信息。 vmstat 命令: top: 命令 IO iostat 命令&#xff1a; Memory free 命令&#xff1a; 温馨提示&#xff1a…
阅读更多...
Qt应用开发(基础篇)——日历 QCalendarWidget

Qt应用开发(基础篇)——日历 QCalendarWidget

一、前言 QCalendarWidget类继承于QWidget&#xff0c;是Qt设计用来让用户更直观的选择日期的窗口部件。 时间微调输入框 QCalendarWidget根据年份和月份初始化&#xff0c;程序员也通过提供公共函数去改变他们&#xff0c;默认日期为当前的系统时间&#xff0c;用户通过鼠标和…
阅读更多...
《C语言编程环境搭建》工欲善其事 必先利其器

《C语言编程环境搭建》工欲善其事 必先利其器

C语言编译器 GCC 系列 GNU编译器套装(英语&#xff1a;GNU Compiler Collection&#xff0c;缩写为GCC)&#xff0c;指一套编程语言编译器&#xff0c;常被认为是跨平台编译器的事实标准。原名是&#xff1a;GNU C语言编译器(GNU C Compiler)。 MinGW 又称mingw32 &#xff0c…
阅读更多...
C语言练习5（巩固提升）

C语言练习5（巩固提升）

C语言练习5 选择题 选择题 1&#xff0c;下面代码的结果是&#xff1a;( ) #include <stdio.h> #include <string.h> int main() {char arr[] { b, i, t };printf("%d\n", strlen(arr));return 0; }A.3 B.4 C.随机值 D.5 &#x1f4af;答案解析&#…
阅读更多...
Unittest 笔记：unittest拓展生成HTM报告

Unittest 笔记：unittest拓展生成HTM报告

HTMLTestRunner 是一个unitest拓展可以生成HTML 报告 下载地址&#xff1a;GitHub: https://github.com/defnnig/HTMLTestRunner HTMLTestRunner是一个独立的py文件&#xff0c;可以放在Lib 作为第三方模块使用或者作为项目的一部分。 方式1&#xff1a; 验证是否安装成功&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023