实例1：抽象方法应用
1 //int *pointer = new int;//声明一个整型指针，并在程序运行时将它指向分配的内存空间
2 //delect *pointer;//删除指针，释放内存
3 #include <iostream>
4 #include <string>
5
6 using namespace std;
7
8 class Pet//定义Pet类
9 {
10 public:
11 Pet(string theName);//构造器,对count进行写操作
12
13 virtual void eat();
14 virtual void sleep();
15 virtual void play() = 0;//定义抽象方法play,具体只需在继承类中声明实现即可，基类中不需要具体实现
16
17 protected://不允许没有继承Pet类的其它类调用
18 string name;
19 };
20 Pet::Pet(string theName)
21 {
22 name = theName;
23 }
24 void Pet::eat()
25 {
26 cout << name << "正在吃东西！\n";
27 }
28 void Pet::sleep()
29 {
30 cout << name << "正在睡大觉！\n";
31 }
32
33 class Cat:public Pet//定义Cat类继承于Pet类
34 {
35 public:
36 Cat(string theName);//构造器
37
38 void climb();
39 void play();
40 };
41 Cat::Cat(string theName):Pet(theName)//Cat的构造函数继承于Pet类中的Pet(theName)函数
42 {
43 }
44 void Cat::climb()
45 {
46 cout << name << "正在爬树！\n";
47 }
48 void Cat::play()
49 {
50 cout << name << "玩毛绒球！\n";
51 }
52
53 class Dog:public Pet//定义Dog类继承于Pet类
54 {
55 public:
56 Dog(string theName);//构造器
57
58 void bark();
59 void play();
60 };
61 Dog::Dog(string theName):Pet(theName)//Dog的构造函数继承于Pet类中的Pet(theName)函数
62 {
63 }
64 void Dog::bark()
65 {
66 cout << name << "汪汪汪！\n";
67 }
68 void Dog::play()
69 {
70 //Pet::play();
71 cout << name << "正在追赶那只该死的猫！\n";
72 }
73 int main()
74 {
75 Pet *cat = new Cat("加菲");
76 Pet *dog = new Dog("欧迪");
77
78 cat -> sleep();
79 cat -> eat();
80 cat -> play();
81
82 dog -> sleep();
83 dog -> eat();
84 dog -> play();
85
86 delete cat;
87 delete dog;
88
89 return 0;
90 }
多态性：是指用一个名字定义不同的函数，调用同一个名字的函数，却执行不同的操作，从而实现传说中的“一个接口，多种方法”。
一般类的析构函数都是释放内存资源，如果析构函数不被调用的话将会造成内存泄漏。
析构器定义为虚方法是为了当一个基类的指针删除一个派生类的对象时，派生类的析构函数可以被正确调用。
当类里面有虚函数时，编译器会给类添加一个虚函数表，里面存放着虚函数指针。为了节省资源，只有当一个类被用来作为基类时，我们才把析构函数写成虚函数。
实例2：析构函数解析
1 #include <iostream>
2 //析构器都是虚方法
3 using namespace std;
4
5 class ClxBase//定义基类ClxBase
6 {
7 public:
8 ClxBase()//构造器
9 {
10 cout << "ClxBase begin!\n";
11 };
12 virtual ~ClxBase()//析构器 ，如果其不为虚函数，则子类的析构函数将不被执行,将造成内存泄漏
13 {
14 cout << "ClxBase end!\n";
15 };
16 virtual void doSomething()//定义抽象方法doSomething 具体只需在继承类中声明实现即可(便可覆盖基类中定义)，基类中可以不具体实现
17 {
18 cout << "Do something in class ClxBase!\n";
19 }
20 };
21
22 class ClxDerived:public ClxBase//定义子类ClxDerived继承于基类ClxBase
23 {
24 public:
25 ClxDerived()//子类构造器
26 {
27 cout << "ClxDerived begin!\n";
28 };
29 ~ClxDerived()//子类析构器
30 {
31 cout << "Output from the destructor of class ClxDerived!\n";
32 };
33 void doSomething()
34 {
35 cout << "Do something in class ClxDerived!\n";
36 };
37 };
38
39 int main()
40 {
41 ClxBase *pTest = new ClxDerived;//定义一个pTest指针指向继承于ClxBase的ClxDerived对象，并为此指针分配内存
42 pTest -> doSomething();
43
44 delete pTest;
45
46 return 0;
47 }