参考:https://blog.csdn.net/zhang_cherry/article/details/108647349
1、函数重写（覆盖）
定义：子类中实现了一个与父类的成员函数原型完全相同的函数，即为重写。
例子1：下面的代码中定义了Animal父类和Dog子类，其中都定义了void info()函数，Dog类中的void info()函数重写（覆盖）了父类了中的info函数，所以在main函数中调用Dog类的info函数时，会调用子类的info函数，即重新写了该函数，或称之为覆盖了父类的info函数。
#include<iostream>
using namespace std;
//父类
class Animal
{
protected:
char animalName[30];
int height;
public:
Animal(char* name, int h)
{
strcpy_s(animalName, name);
height = h;
}
void info()
{
cout << "I am an animal" << endl;
cout << "My name is " << animalName <<", height: "<<height << endl;
}
};
//子类
class Dog :public Animal
{
private:
char voice[30];
public:
Dog(char* name, int h, char* v) :Animal(name, h)
{
strcpy_s(voice, v);
}
void info()
{
cout << "I am a dog" << endl;
cout << "My name is " << animalName << ", height: " << height << endl;
}
};
int main()
{
Animal a("cat", 20);
Dog d("dog", 40, "wang");
d.info();
system("pause");
return 0;
}
实验结果：
I am a dog
My name is dog, height: 40
为了调用父类的info函数，可以采用 子类对象名.父类名::函数名 形式，如： d.Animal::info();
2、虚函数
定义：通过virtual关键字将类的成员函数定义为虚函数。一般是将父类中与子类函数原型完全相同的成员函数定义为虚函数。
作用：（1）通过使用父类的指针或引用指向子类时，指针或引用可以向下调用子类的函数。（2）实现多态。
例子2：修改例子1父类（Animal类）中的info函数为虚函数。在主函数中，定义了一个父类类型的指针，它指向了子类对象，当调用info函数时，调用的是子类的info函数，实现了向下转型。同理，通过引用的方式，也可以调用子类的成员函数info。
#include<iostream>
using namespace std;
//父类
class Animal
{
protected:
char animalName[30];
int height;
public:
Animal(char* name, int h)
{
strcpy_s(animalName, name);
height = h;
}
virtual void info()
{
cout << "I am an animal" << endl;
cout << "My name is " << animalName <<", height: "<<height << endl;
}
};
class Dog :public Animal
{
private:
char voice[30];
public:
Dog(char* name, int h, char* v) :Animal(name, h)
{
strcpy_s(voice, v);
}
void info()
{
cout << "I am a dog" << endl;
cout << "My name is " << animalName << ", height: " << height << endl;
}
};
int main()
{
Animal a("cat", 20);
Dog d("dog", 40, "wang");
Animal* ptr = &d;
ptr->info();
Dog d1("dog1", 42, "wang wang");
Animal& p1 = d1;
p1.info();
system("pause");
return 0;
}
实验结果：
I am a dog
My name is dog, height: 40
I am a dog
My name is dog1, height: 42
虚函数是多态的充分条件。多态，即为多种形态，意思是：父类的指针或引用能够操作不同的子类对象。
例子3：下面又定义了一个Elegent子类，在主函数中，使用父类指针指向了Elegent类的对象，可以看到，ptr1->info();这句话，由于ptr1指向的对象不同，info()执行的函数也不同，即表现为多种形态。
#include<iostream>
using namespace std;
//父类
class Animal
{
protected:
char animalName[30];
int height;
public:
Animal(char* name, int h)
{
strcpy_s(animalName, name);
height = h;
}
virtual void info()
{
cout << "I am an animal" << endl;
cout << "My name is " << animalName <<", height: "<<height << endl;
}
};
class Dog :public Animal
{
private:
char voice[30];
public:
Dog(char* name, int h, char* v) :Animal(name, h)
{
strcpy_s(voice, v);
}
void info()
{
cout << "I am a dog" << endl;
cout << "My name is " << animalName << ", height: " << height << endl;
}
};
class Elegent :public Animal
{
public:
Elegent(char* name, int h) :Animal(name, h)
{
}
void info()
{
cout << "I am an elegent" << endl;
cout << "My name is " << animalName << ", height: " << height << endl;
}
};
int main()
{
Animal a("cat", 20);
Dog d("dog", 40, "wang");
Animal* ptr = &d;
ptr->info();
Elegent e("elegent", 80);
Animal* ptr1 = &e;
ptr1->info();
system("pause");
return 0;
}
实验结果：
I am a dog
My name is dog, height: 40
I am an elegent
My name is elegent, height: 80
3、纯虚函数
定义：虚函数只声明，函数体为0，即为纯虚函数。拥有纯虚函数的类称之为抽象类。
作用：（1）父类中定义了一个纯虚函数，它的派生类（子类）必须定义，若不定义，则派生类也成为了抽象类，但是抽象类不能定义对象。（2）纯虚函数为不同种类的子类对象提供了一个通用接口。
例子4：
#include<iostream>
using namespace std;
class A
{
private:
int a;
public:
A(int _a=0):a(_a){}
virtual void print() = 0; //纯虚函数
};
class B :public A
{
private:
int b;
public:
B(int _a, int _b):A(_a),b(_b){}
void print()
{
cout << "B Class" << " " << b << endl;
}
};
int main()
{
//A a(1); //出错，因为抽象类不能定义对象
B b(1, 2);
b.print();
system("pause");
return 0;
}
总结：
函数重写、虚函数、纯虚函数的联系：父类与子类的函数原型完全相同，和函数重载有区别。
区别：（1）函数重写，是子类成员函数覆盖父类的成员函数；（2）虚函数，是将父类的成员函数定义为虚函数，方便父类向子类的向下转型；（3）纯虚函数是在父类中，将虚函数的函数体置为0，为子类提供了一个接口，子类必须要实现该函数。
