2024年最新【C++进阶】多态(万字详解）(3)，2024年最新字节跳动最新开源

最新推荐文章于 2024-08-22 19:20:50 发布

2401_84976491

最新推荐文章于 2024-08-22 19:20:50 发布

阅读量881

点赞数 21

分类专栏：程序员文章标签： c语言 c++ 学习

本文链接：https://blog.csdn.net/2401_84976491/article/details/138851722

版权

程序员专栏收录该内容

53 篇文章 0 订阅

订阅专栏

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

{
public:
void fun(int i)
{
cout << “fun(int i)” << endl;
}
};


**构成多态的条件之一是虚函数的重写，而虚函数也有自己的规则，虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数，即派生类虚函数和基类虚函数的返回值类型、函数名、参数列表完全相同，就称子类的虚函数重写了基类的虚函数。**


**注意区分隐藏的概念，隐藏是只要基类函数名和派生类函数名相同即是隐藏或重定义。不构成重写则构成隐藏**




---


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


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


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

#include
using namespace std;

//class A {};//AB为无关联的类
//class B {};
class A {};//AB为关联的父子类
class B : public A {};

class Person
{
public:
virtual A* BuyTicket()
{
cout << “正常排队-全价买票” << endl;
return new A;
}
protected:
int _age;
string _name;
};
class Student : public Person
{
public:
virtual B* BuyTicket()
{
cout << “正常排队-半价买票” << endl;
return new B;
}
protected:
//…
};
void Func(Person& ptr)
{
ptr.BuyTicket();
}

int main()
{
Person ps;
Student st;

Func(ps);
Func(st);

return 0;

}


如果返回值是有关联的父子类，那么虽然它不满足三同，但是它满足协变这个例外，所以能构成多态。


![请添加图片描述](https://img-blog.csdnimg.cn/41156a517c7747a1b03ec4b588c06bad.png)


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


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


`普通析构`

#include
using namespace std;

class Person
{
public:
//~Person()
virtual ~Person()
{
cout << “~Person()” << endl;
}
};
class Student : public Person
{
public:
//~Student()
virtual ~Student()
{
cout << “~Student()” << endl;
}
};

int main()
{
//普通场景
Person p;
Student s;

//new对象的特殊场景 
Person\* p1 = new Person;
Person\* p2 = new Student;

delete p1;//p1->destructor() + operator delete(p1)
delete p2;//p2->destructor() + operator delete(p2)

return 0;

}


![请添加图片描述](https://img-blog.csdnimg.cn/dcd22f4a4a8a40d1a48dd3dc86aaabdf.png)


在继承中我们说过，子类中要去显示的调用父类的析构函数，需要指定作用域，因为所有类的析构函数名都被处理成了 destructor()，所以子类和父类的析构函数构成隐藏关系。为什么它要对析构函数名作单独处理呢，因为如果这里不构成多态，调用时看的是指针的类型，那么这里 p1 和 p2 调用的都是 Person 的析构函数，此时就不对了。子类对象应该先调用子类的析构函数，再去调用父类的析构函数，万一子类对象中需要 delete，那么 Student 的析构函数没调到就有可能会出现资源泄漏。

#include
#include
using namespace std;

class Person
{
public:
virtual void BuyTicket()
{
cout << “正常排队-全价买票” << endl;
}
protected:
int _age;
string _name;
};
class Student : public Person
{
public:
void BuyTicket()//可以不加virtual
{
cout << “正常排队-半价买票” << endl;
}
protected:
//…
};
void Func(Person* ptr)
{
ptr->BuyTicket();
}

int main()
{
Person ps;
Student st;

Func(&ps);
Func(&st);

return 0;

}


![请添加图片描述](https://img-blog.csdnimg.cn/4ab72e95464049c9a5ef330775cf2863.png)  
 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。




---


### 🍉2.4 C++11 override 和 final


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


* final：修饰虚函数，表示该虚函数不能再被重写

#include
using namespace std;

class Car
{
public:
virtual void Drive() final
{}
};
class Benz : public Car
{
public:
virtual void Drive()
{
cout << “Benz-舒适” << endl;
}
};

int main()
{
return 0;
}


![请添加图片描述](https://img-blog.csdnimg.cn/ecbefe3b5fb247b78de721f82b6e6041.png)


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

#include
using namespace std;

class Car
{
public:
virtual void Drive() {}
};
class Benz : public Car
{
public:
//virtual void Drive() override//ok,重写
//{
// cout << “Benz-舒适” << endl;
//}

//void Drive() override//ok,属于重写的例外
//{ 
// cout << "Benz-舒适" << endl; 
//}

virtual void Drive(int) override//err,没有完成重写
{
	cout << "Benz-舒适" << endl;
}

};
int main()
{
return 0;
}


![请添加图片描述](https://img-blog.csdnimg.cn/5728acb2bfb746569b0deb00ac8649b3.png)




---


### 🍉 2.5 重载、覆盖(重写)、隐藏(重定义)的对比


![在这里插入图片描述](https://img-blog.csdnimg.cn/f3aa97446ab54aacb80165bbafa3a7c7.png)




---


## 🍇3. 抽象类


### 🍉3.1 概念


抽象这个词，我们理解的场景是 “ 你长的好抽象 ” 或 “ 抽象派画家画的画好抽象 ”。本质抽象类指的是在现实世界中没有具体的对应实物，也就没必要实例化对象


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

#include
using namespace std;

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

int main()
{
Benz bz;

Car\* pBenz = new Benz;
pBenz->Drive();

Car\* pBMW = new BMW;
pBMW->Drive();	

return 0;

}


接口类相比抽象类的概念更广泛，你可以认为一个类的公有成员函数是接口，换一个角度，如果一个类设计的不规范，也不能说公有的成员函数就是接口。但更重要的是纯虚函数只有声明，没有定义，所以有些地方叫接口类。




---


### 🍉 3.2 接口继承和实现继承


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




---


## 🍇 4.多态的原理


### 🍉 4.1虚函数表

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


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/b24e8de98f4b400fa16decff22042c36.png)

// 针对上面的代码我们做出以下改造
// 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下是存在代码段的。![在这里插入图片描述](https://img-blog.csdnimg.cn/7e76fe1249b34be2a0e2a794a077b900.png)




---


### 🍉 4.2 多态的原理


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/769a626147814fa8a769aee6228c5eae.png)

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。
2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。


![在这里插入图片描述](https://img-blog.csdnimg.cn/e85606d3a24f465b972061fe1d9259a7.png)

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
00头1940EC cmp esi,esp
}

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




---


### 🍉 4.3 动态绑定与静态绑定


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




---


## 🍇 5.单继承和多继承关系的虚函数表


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


### 🍉5.1 单继承中的虚函数表

#include
using namespace std;

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的虚表呢？下面我们使用代码打印出虚表中的函数。


![在这里插入图片描述](https://img-blog.csdnimg.cn/faa6bfd273024da9b87e125a888eff4d.png)

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;

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/43de8eb359f44212a52e3f2f0a3c6b93.png)




---


### 🍉5.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;

}


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


![在这里插入图片描述](https://img-blog.csdnimg.cn/a6a0f2eb75134897bce3caacefec899b.png)




---


### 🍉5.3 菱形继承、菱形虚拟继承


实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的  
 模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看  
 了，一般我们也不需要研究清楚，因为实际中很少用。如果好奇心比较强的宝宝，可以去看下面  
 的两篇链接文章。


* [虚函数表解析](https://bbs.csdn.net/topics/618668825)
* [对象多内存布局](https://bbs.csdn.net/topics/618668825)




---


## 🍇 6. 继承和多态常见的面试问题


### 🍉6.1 概念查考


1. 下面哪种面向对象的方法可以让你变得富有( )


A: 继承 B: 封装 C: 多态 D: 抽象



> 
> **A，继承机制是面向对象程序设计使代码可以复用的最重要手段，继承是类设计层次的复用。**
> 
> 
> 


2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。


A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定



> 
> **D，动态绑定又称后期绑定或晚绑定，就是多态。**
> 
> 
> 


3. 面向对象设计中的继承和组合，下面说法错误的是？（）


A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用


B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用


C：优先使用继承，而不是组合，是面向对象设计的第二原则


D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现



> 
> **C，优先使用组合，而不是继承。**
> 
> 
> 


4. 以下关于纯虚函数的说法,正确的是( )


A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类  
 C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数




![img](https://img-blog.csdnimg.cn/img_convert/74c055f2bbd1d42ab62b11cf3d45e6e6.png)
![img](https://img-blog.csdnimg.cn/img_convert/7bf4ad625b4cf89172cf1b3037455539.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

可以复用的最重要手段，继承是类设计层次的复用。**
> 
> 
> 


2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。


A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定



> 
> **D，动态绑定又称后期绑定或晚绑定，就是多态。**
> 
> 
> 


3. 面向对象设计中的继承和组合，下面说法错误的是？（）


A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用


B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用


C：优先使用继承，而不是组合，是面向对象设计的第二原则


D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现



> 
> **C，优先使用组合，而不是继承。**
> 
> 
> 


4. 以下关于纯虚函数的说法,正确的是( )


A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类  
 C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数




[外链图片转存中...(img-EbcbUlS1-1715665073983)]
[外链图片转存中...(img-Cxf1K8FQ-1715665073983)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**

2401_84976491

关注

21
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
2024年最新【C++进阶】多态(万字详解）(3)，2024年最新字节跳动最新开源

/ 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址。//思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。调用就可以看出存的是哪个函数。
复制链接

扫一扫