【C++】详解多态

news2024/11/23 22:17:40

目录

  • 一、多态的概念
  • 二、多态的定义及实现
    • 1、多态的构成条件
    • 2、虚函数
    • 3、虚函数的重写
      • 1、虚函数重写的两个例外
    • 4、C++11 override 和 final
    • 5、重载、覆盖(重写)、隐藏(重定义)的对比
  • 三、抽象类
    • 1、概念
    • 2、接口继承和实现继承
  • 四、多态的原理
    • 1、虚函数表
    • 2、多态的原理
    • 3、动态绑定与静态绑定
  • 五、单继承和多继承关系的虚函数表
    • 1、单继承中的虚函数表
    • 2、多继承中的虚函数表

一、多态的概念

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

举个例子：比如去车站买票的这个行为，当普通人买票时，是全价买票，而学生买票时，是半价买票，军人买票时，是优先买票。同样是买票，但是不同的用户买票，价位不同，这就是一种多态行为。

二、多态的定义及实现

1、多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生不同的行为。
在继承中要构成多态还有两个条件：

  1. 必须通过基类的指针或者引用去调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
    在这里插入图片描述

2、虚函数

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

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

3、虚函数的重写

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

举个例子：

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

class Student :public Person
{
public:

	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
void Func(Person& people)
{
	people.BuyTicket();
}

void Test()
{
	Person Mike;
	Func(Mike);

	Student Johnson;
	Func(Johnson);
}

运行结果：
在这里插入图片描述
注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写（因为继承后基类的虚函数被继承下来了，在派生类中依旧保持虚函数的属性），但是这种写法不规范，不建议这样使用
如下所示：

void BuyTicket()
{
	cout << "买票-半价" << endl;
}

1、虚函数重写的两个例外

  1. 协变（基类与派生类虚函数返回值类型不同）
    派生类重写基类虚函数时，与基类虚函数返回值类型可以不同。 即基类虚函数返回值基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
class Person 
{
public:
	virtual Person* BuyTicket()
	{ 
		cout << "买票-全价" << endl;
		return this;
	}
};
	
class Student : public Person 
{
public:
	virtual Student* BuyTicket()
	{ 
		cout << "买票-半价" << endl;
		return this;
	}
};

void Func(Person* p)
{
	p->BuyTicket();
	delete p;
}
	
int main()
{
	Func(new Person);
	Func(new Student);
	
	return 0;
}
  1. 析构函数的重写（基类与派生类析构函数的名字不同）
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，即使函数名不相同，都与基类的析构函数构成重写，因为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成 destructor。
class Person 
{
public:
	virtual ~Person() 
	{
		cout << "~Person()" << endl; 
	}
};

class Student : public Person 
{
public:
	virtual ~Student()
	{ 
		cout << "~Student()" << endl; 
	}
};

int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

注意：只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。

4、C++11 override 和 final

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

  1. final：修饰虚函数，表示该虚函数不能再被重写
    举个例子：
class Person {
public:
	virtual void BuyTicket() final
	{ 
		cout << "买票-全价" << endl; 
	}
};
class Student : public Person {
public:
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};

在这里插入图片描述

  1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
    举个例子：
class Person {
public:
	virtual void BuyTicket() 
	{
		cout << "买票-全价" << endl;
	}
};
class Student : public Person {
public:
	virtual void BuyTicket1() override
	{
		cout << "买票-半价" << endl;
	}
};

在这里插入图片描述

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

在这里插入图片描述

三、抽象类

1、概念

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

举个例子：

class Person 
{
public:
	virtual void BuyTicket() = 0;
};

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

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

void Test()
{
	Person* p1 = new Student1;
	p1->BuyTicket();

	Person* p2 = new Student2;
	p2->BuyTicket();
}

2、接口继承和实现继承

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

四、多态的原理

1、虚函数表

我们先看看下面这到题：

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

int main()
{
	Base b;
	cout << sizeof(Base) << endl;
	return 0;
}

运行结果：
在这里插入图片描述
在这里插入图片描述
通过运行与观察监视窗口，我们发现b对象是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. 总结一个派生类的虚表生成：第一，先将基类中的虚表内容拷贝一份到派生类虚表中；第二，如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数；第三，派生类自己新增的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
  6. 那么虚函数存在哪里？虚表存在哪里？
    虚函数存在虚表中，虚表存在对象中，这是错误的理解。 虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段中，只是他的指针存到了虚表中。而对象中存的也不是虚表，存的是虚表指针，而虚表也是存在代码段中的。

2、多态的原理

上面分析了什么是虚表，那么多态的原理到底是什么呢？我们看看下面这串代码：

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

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

void Func(Person* p)
{
	p->BuyTicket();
}

int main()
{
	Person Mike;
	Func(&Mike);
	Student Johnson;
	Func(&Johnson);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

通过观察

  1. 我们可以看到p是指向Mike对象时，p->BuyTicket在Mike的虚表中找到虚函数是Person::BuyTicket
    p是指向Johnson对象时，p->BuyTicket在Johnson的虚表中找到虚函数是Student::BuyTicket
  2. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
    我们在通过观察汇编代码分析，可以看出满足多态以后的函数调用，不是在编译时确定的，是在运行起来以后到对象中去找到。不满足多态的函数调用是在编译时确认好的。

3、动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

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

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;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

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

class Base 
{
public:
	Base()
		:a(10)
	{
		++a;
	}

	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 d;
};

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << "虚表地址 > " << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf("第%d个虚函数地址 :%p -> ", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Base b;
	Derive d;
	PrintVTable((VFPTR*)(*(int*)&b));
	PrintVTable((VFPTR*)(*(int*)&d));

	return 0;
}

思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr

  1. 先取b的地址，强转成一个int*的指针
  2. 再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
  3. 再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
  4. 虚表指针传递给PrintVTable进行打印虚表
  5. 需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再编译就好了。
    在这里插入图片描述

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;
	int bb;
};
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个虚函数地址 : %p -> ", 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;
}

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

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

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

相关文章

Mysql架构篇--Mysql(M-S) 主从同步

Mysql架构篇--Mysql(M-S) 主从同步

文章目录 前言&#xff1a;一、主从同步是什么&#xff1f;二、主从同步实现&#xff1a;1.准备工作&#xff1a;2.开启主从复制&#xff1a;2.1 mysql 服务端配置文件修改&#xff1a;2.2 mysql master 节点用户创建&#xff1a;2.3 mysql slave 节点开启数据复制&#xff1a;…
阅读更多...
突破传统设计灵感，虚拟展厅设计方案

突破传统设计灵感，虚拟展厅设计方案

导语&#xff1a; 随着科技的不断发展&#xff0c;虚拟展厅设计方案正成为现代设计行业的新宠。这种创新的设计形式不仅突破了传统设计的局限&#xff0c;还为传统设计公司带来了诸多优势和特点&#xff0c;从而提高了设计产量和创意灵感。 在这篇软文中&#xff0c;我们将深入…
阅读更多...
雅迪、爱玛谁是“新宠”？

雅迪、爱玛谁是“新宠”？

电动两轮车下半场&#xff0c;谁是“新王”&#xff1f; 6月15日&#xff0c;爱玛科技有限公司&#xff08;下称“爱玛”&#xff0c;603529.SH)迎来了上市两周年。 作为电动两轮车的头部玩家&#xff0c;雅迪控股有限公司&#xff08;下称“雅迪”&#xff0c;01585.HK&…
阅读更多...
HJ101 输入整型数组和排序标识，对其元素

HJ101 输入整型数组和排序标识，对其元素

描述 输入整型数组和排序标识&#xff0c;对其元素按照升序或降序进行排序 数据范围&#xff1a; 1≤n≤1000 1≤n≤1000 &#xff0c;元素大小满足 0≤val≤100000 0≤val≤100000 输入描述&#xff1a; 第一行输入数组元素个数 第二行输入待排序的数组&#xff0c;每个…
阅读更多...
python实现九九乘法表

python实现九九乘法表

九九乘法表 i 1 while i < 9:j 1while j < i:print(f{j}*{i}{i * j}, end\t)j 1print()i 1结果&#xff1a;
阅读更多...
window10 查看本机TCP协议进程

window10 查看本机TCP协议进程

1. netstat 是一个常见的网络工具&#xff0c;用于显示网络连接状态、路由表、接口统计信息等网络相关的信息&#xff0c;可以帮助诊断和解决网络问题。 其中&#xff0c;各参数的含义为&#xff1a; -a&#xff1a;显示所有的网络连接和监听端口。 -e&#xff1a;显示以太网…
阅读更多...
CDH yarn Fair 队列最大资源使用限制，任务无法提交

CDH yarn Fair 队列最大资源使用限制，任务无法提交

一、问题背景描述 1.任务提交异常日志 2023-06-29 15:48:20,877 INFO org.apache.flink.yarn.YarnClusterDescriptor [] - Deployment took more than 60 seconds. Please check if the requested resources are available in the YARN cluster 2023-06-29 15:48:21,129 IN…
阅读更多...
1-什么是NumPy？【视频版】

1-什么是NumPy？【视频版】

目录 问题解答观看视频 问题 解答 NumPy&#xff0c;全称Numerical Python&#xff0c;是一个开源的Python科学计算库。它为Python提供了大量的数学库&#xff0c;包括&#xff1a; 强大的N维数组对象成熟的广播功能集成C/C和Fortran代码的工具有用的线性代数、傅里叶变换和随…
阅读更多...
第一个spring程序

第一个spring程序

我们今天写第一个spring程序 我们采用maven形式创建工程。 我们首先在pom.xml中加入引用。 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0"xmlns:xsi"http://www.w3.org/2001/XMLSch…
阅读更多...
（6）蜂鸣器(又称音调报警)

（6）蜂鸣器(又称音调报警)

文章目录 6.1 使用有源蜂鸣器而不是无源蜂鸣器 6.2 安装蜂鸣器 6.3 使蜂鸣器安静 蜂鸣器&#xff08;或音调报警器&#xff09;可用于以声音指示飞行器的状态变化。根据电路板的能力&#xff0c;它可以是一个有源设备&#xff08;只需要施加电压来产生一个单一频率的音调&am…
阅读更多...
给定一组数据样本，计算：【样本的平均值】, 【样本的标准差】, 【样本的变异系数】,【样本的标准误差】

给定一组数据样本，计算：【样本的平均值】, 【样本的标准差】, 【样本的变异系数】,【样本的标准误差】

一、指标含义 样本的平均值&#xff1a;指样本中所有数据的总和除以样本大小&#xff0c;是样本的中心趋势的度量。平均值常用于描述数据的集中程度&#xff0c;具有良好的代表性和易于计算的优点。 样本的标准差&#xff1a;指样本中每个数据与平均值的偏差的平方和的平均值的…
阅读更多...
openssl版本升级与降级

openssl版本升级与降级

openssl版本升级与降级 flyfish 环境 Ubuntu 22.04 1.1.1升级3.1.1 查看openssl版本 openssl versionOpenSSL 1.1.1t 7 Feb 2023https://www.openssl.org/source/ 编译和安装 ./config --prefix/usr/local/openssl311 make -j8 make install进入/usr/local/openssl311/l…
阅读更多...
JavaWeb两大组件FILTERLISTENER

JavaWeb两大组件FILTERLISTENER

一.Filter&#xff1a;过滤器 是什么&#xff1a; 当访问服务器的资源时&#xff0c;过滤器可以将请求拦截下来&#xff0c;完成一些特殊的功能。 作用&#xff1a; 一般用于完成通用的操作。如&#xff1a;登录验证、统一编码处理、敏感字符过滤… 具体流程&#xff1a; 原始…
阅读更多...
本地部署 FastChat

本地部署 FastChat

本地部署 FastChat 1. 什么是 FastChat2. Github 地址3. 安装 Miniconda34. 创建虚拟环境5. 安装 FastChat6. 使用命令行进行推理7. 使用 Web GUI 服务进行推理8. 使用 Lora 进行训练9. 其他 文章还在创作中。。。 1. 什么是 FastChat FastChat 是一个开放平台&#xff0c;用…
阅读更多...
同步和异步、同步复位、异步复位、同步释放（Verilog、Verdi、DC综合）

同步和异步、同步复位、异步复位、同步释放（Verilog、Verdi、DC综合）

文章目录 1.同步和异步2. 同步复位、异步复位、同步释放2.1 同步复位2.1.1 Verilog code2.1.2 Verdi waveform2.1.3 DC Synthesis 2.2 异步复位2.2.1 Verilog code 2.3 同步释放&#xff08;异步信号和CLK信号存在时序检查、Recover time&Removel time&#xff09;2.4 异步…
阅读更多...
初识Docker：（7）查询Docker镜像的DockerFile

初识Docker：（7）查询Docker镜像的DockerFile

1. 前言 我们知道了根据dockerfile来制作镜像&#xff0c;如果给你一个现成的镜像&#xff0c;你能逆向查看出dockerfile吗&#xff1f; 否则&#xff0c;你怎么知道该镜像使用的是CMD还是ENTRYPOINT &#xff0c;使用的是shell格式还是CMD格式&#xff1f;由于格式决定了doc…
阅读更多...
numpy反向传播算法示例

numpy反向传播算法示例

numpy反向传播算法示例 数据 通过 scikit-learn 库提供的便捷工具生成 2000 个线性不可分的 2 分类数据集 按着7: 3比例切分训练集和测试集 backpropagation.py #!/usr/bin/env python # encoding: utf-8 """ desc: 反向传播算法 """impor…
阅读更多...
leetcode电话号码的字母组合C++实现教程

leetcode电话号码的字母组合C++实现教程

链接: 电话号码的字母组合 class Solution {char* PNumStr[10] {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};//因为每次都需要执行拷贝&#xff0c;…
阅读更多...
了解嵌入式系统的不同细分领域：探索嵌入式BSP的定义

了解嵌入式系统的不同细分领域：探索嵌入式BSP的定义

嵌入式BSP是指嵌入式系统中的板级支持软件。它是针对特定硬件平台的软件包&#xff0c;提供了操作系统和硬件之间的抽象层&#xff0c;以便开发人员可以更方便地使用硬件功能和编写应用程序。 嵌入式BSP的功能包括&#xff1a; 设备初始化和配置&#xff1a;BSP负责初始化硬件设…
阅读更多...
学做测试平台开发-Vuetify 框架

学做测试平台开发-Vuetify 框架

Vuetify 是 Vue 的语义化组件框架&#xff0c;旨在提供整洁、语义化和可重用的组件&#xff0c;使得构建应用程序更方便。 Vuetify 核心是为了提供各种可重复使用的&#xff0c;即插即用并且适合各种项目规格的组件。 Vue 的语义成分。利用 Vue 的功能组件&#xff0c;所有基…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023