标签：期望 pre student 实例 实现 let ++ 崩溃 ret
virtual用法一：多态
1 #include<iostream> 2 using namespace std; 3 class A{ 4 public: 5 virtual void display(){ cout<<"A"<<endl; } 6 }; 7 class B : public A{ 8 public: 9 void display(){ cout<<"B"<<endl; } 10 }; 11 void doDisplay(A *p) 12 { 13 p->display(); 14 delete p; 15 } 16 17 int main(int argc,char* argv[]) 18 { 19 doDisplay(new B()); 20 return 0; 21 }
这段代码打印出的结果为B，但是当把A类中的virtual去掉之后打印出的就为A。当基类中没有virtual的时候，编译器在编译的时候把p看做A类的对象，调用的自然就是A类的方法。但是加上virtual之后，将dispaly方法变成了虚方法，这样调用的时候编译器会看调用的究竟是谁的实例化对象，这样就实现了多态的效果。也就是说，当基类的派生类中有重写过基类的虚方法的时候，使用基类的指针指向派生类的对象，调用这个方法实际上调用的会是派生类最后实现的方法。
virtual用法二: 虚继承：解决数据冗余
1 #include<iostream> 2 using namespace std; 3 class Person{ 4 public: Person(){ cout<<"Person构造"<<endl; } 5 ~Person(){ cout<<"Person析构"<<endl; } 6 }; 7 class Teacher : virtual public Person{ 8 public: Teacher(){ cout<<"Teacher构造"<<endl; } 9 ~Teacher(){ out<<"Teacher析构"<<endl; } 10 }; 11 class Student : virtual public Person{ 12 public: Student(){ cout<<"Student构造"<<endl; } 13 ~Student(){ cout<<"Student析构"<<endl; } 14 }; 15 class TS : public Teacher, public Student{ 16 public: TS(){ cout<<"TS构造"<<endl; } 17 ~TS(){ cout<<"TS析构"<<endl; } 18 }; 19 int main(int argc,char* argv[]) 20 { 21 TS ts; 22 return 0; 23 }
这段代码的终端输出结果为：
1 Person构造 2 Teacher构造 3 Student构造 4 TS构造 5 TS析构 6 Student析构 7 Teacher析构 8 Person析构
当Teacher类和Student类没有虚继承Person类的时候，也就是把virtual去掉时候终端输出的结果为：
1 Person构造 2 Teacher构造 3 Person构造 4 Student构造 5 TS构造 6 TS析构 7 Student析构 8 Person析构 9 Teacher析构 10 Person析构
大家可以很清楚的看到这个结果明显不是我们所期望的。我们在构造TS的时候需要先构造他的基类，也就是Teacher类和Student类。而Teacher类和Student类由都继承于Person类。这样就导致了构造TS的时候实例化了两个Person类。同样的道理，析构的时候也是析构了两次Person类，这是非常危险的，也就引发出了virtual的第三种用法，虚析构。
virtual用法三:虚析构：可以防止内存泄漏
1 #include<iostream> 2 using namespace std; 3 class Person{ 4 public: Person() {name = new char[16];cout<<"Person构造"<<endl;} 5 virtual ~Person() {delete []name;cout<<"Person析构"<<endl;} 6 private: 7 char *name; 8 }; 9 class Teacher :virtual public Person{ 10 public: Teacher(){ cout<<"Teacher构造"<<endl; } 11 ~Teacher(){ cout<<"Teacher析构"<<endl; } 12 }; 13 class Student :virtual public Person{ 14 public: Student(){ cout<<"Student构造"<<endl; } 15 ~Student(){ cout<<"Student析构"<<endl; } 16 }; 17 class TS : public Teacher,public Student{ 18 public: TS(){ cout<<"TS构造"<<endl; } 19 ~TS(){ cout<<"TS析构"<<ENDL; } 20 }; 21 int main(int argc,char* argv[]) 22 { 23 Person *p = new TS(); 24 delete p; 25 return 0; 26 }
这段代码的运行结果为：
1 Person构造 2 Teacher构造 3 Student构造 4 TS构造 5 TS析构 6 Student析构 7 Teacher析构 8 Person析构
但是当我们把Person类中析构前面的virtual去掉之后的运行结果为：
1 Person构造 2 Teacher构造 3 Student构造 4 TS构造 5 Person析构 6 程序崩溃
很明显这个结果不是我们想要的程序，崩溃造成的后果是不可预计的，所以我们一定要注意在基类的析构函数前面加上virtual，使其变成虚析构在C++程序中使用虚函数，虚继承和虚析构是很好的习惯 可以避免许多的问题。
原文：https://blog.csdn.net/jirryzhang/article/details/79392934
标签：期望 pre student 实例 实现 let ++ 崩溃 ret
原文地址：https://www.cnblogs.com/hairuijy/p/10483010.html
