C++类中的函数重写（覆盖）、虚函数、纯虚函数的区别与联系

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. 区别：（1）函数重写，是子类成员函数覆盖父类的成员函数；（2）虚函数，是将父类的成员函数定义为虚函数，方便父类向子类的向下转型；（3）纯虚函数是在父类中，将虚函数的函数体置为0，为子类提供了一个接口，子类必须要实现该函数。

如果觉得对您有帮助，请帮忙点个赞吧！谢谢！