Pure virtual function

1. Just give the declaration in the base class , No virtual function implementation is defined , Instead, implement... In a derived class . This virtual function is called pure virtual function . If an ordinary function only gives its declaration and does not implement its function body , This can't be compiled . A pure virtual function has no body , A pure virtual function needs to be declared with =0;

2. Define format ：

class < Base class name >
{

	virtual < type >< Function name >(< Parameter table >)=0; 
	......
	
};

3. Classes with pure virtual functions are called abstract classes

   1. Classes with pure virtual functions are called abstract classes . Abstract classes can only be used as the base class of derived classes , Cannot define objects , But you can define pointers . After the derived class implements the pure virtual function , Define a pointer to an abstract class object , And point to or reference subclass objects .

   2. In defining pure virtual functions , You can't define the implementation part of a virtual function ;

   3. Before redefining this pure virtual function , You can't call this function .

   4. The only purpose of an abstract class is to provide a base class for derived classes , Pure virtual functions are used as the basis of member functions in derived classes , And realize dynamic polymorphism . If the derived class inherited from the abstract class cannot implement all the pure virtual functions in the base class , Then the derived class becomes an abstract class . Because it inherits the abstract functions of the base class , A class that contains pure virtual functions is an abstract class . The pure virtual function has defined the declaration of this method in the abstract class , Other classes can only implement according to this interface .

4. The difference between interface and abstract class

   1. C++ The interface we generally call in , Means the method provided externally , Provided to external calls . It is a bridge between the outside and the inside . It is also provided in the form of classes , But generally, this class only has member functions , No data members ;

   2. Abstract classes can contain both data members and methods .

An instance of an abstract class

1. abstract class IShape As the base class ： Only header files , No implementation file

	
	#ifndef SHAPE_H

	#define SHAPE_H

	#include

	using std::string;

	//interface

	class IShape

	{

		public:
	
		virtual float getArea()=0; // Pure virtual function , Get the area 
	
		virtual string getName()=0; // Pure virtual function , Returns the name of the drawing 

	};

	#endif

	2. Derived class Circle Class inherits from abstract class IShape：

	Circle.h The header file ：

	#ifndef CIRCLE_H

	#define CIRCLE_H

	#include"Shape.h"

	class CCircle : public IShape // The public is inherited from IShape class 

	{

		public:
	
		CCircle(float radius); // Constructors 
	
		public:
	
		virtual float getArea(); // Implementation declaration implements functions of two base classes , When declaring, you need to add virtual keyword , There is no need to add virtual Keyword. .
	
		virtual string getName();
	
		private:
	
		float m_fRadius; // Derived classes can have their own members 

	};

	#endif


	Circle.cpp Implementation file ：

	#include"Circle.h"

	CCircle::CCircle(float radius)

	:m_fRadius(radius) // Use the initialization list of the constructor to initialize 
	{
	}

	float CCircle::getArea() / / Implement functions that implement two base classes 

	virtual string getName();
	{
		return 3.14 * m_fRadius * m_fRadius;
	}

	string CCircle::getName()

	{

		return "CCircle";

	}


	3.  Derived class Rect Class inherits from abstract class IShape：

	Rect.h The header file ：

	#ifndef RECT_H

	#define RECT_H

	#include"shape.h"

	class CRect : public IShape

	{

		public:
	
		CRect(float nWidth, float nHeight);
	
		public:
	
		virtual float getArea();
	
		virtual string getName();
	
		private:
	
		float m_fWidth; // The rectangle class has its own two properties , Width and height 
	
		float m_fHeight;

	};

	Rect.cpp Implementation file ：

	#include"Rect.h"

	CRect::CRect(float fWidth, float fHeight)

	:m_fWidth(fWidth), m_fHeight(fHeight)

	{

	}

	float CRect::getArea()

	{

		return m_fWidth * m_fHeight;

	}

	string CRect::getName()

	{

		return "CRect";

	}


	4. The test file main.cpp：

	#include

	#include"Rect.h"

	#include"Circle.h"

	using namespace std;

	int main()

	{

		IShape* pShape = NULL; // Defines a pointer to an abstract class , Note that abstract classes cannot define objects but can define pointers 
		
		pShape = new CCircle(20.2); // The base class pointer points to the object of the derived class 
	
		cout<getName()<<" "<getArea()<<endl;
	
		delete pShape; // The release of the CCirle Memory occupied by objects , But the pointer doesn't disappear , It is now a wild pointer , We must assign a value to it before using 
	
		pShape = new CRect(20, 10); // The base class pointer points to the object of the derived class 
	
		cout<getName()<<" "<getArea()<<endl;
	
		return 0;

	}
	

The operation results are as follows ： You can see , We use the pointer of the parent class to call the same function , The corresponding functions of these two derived classes are called respectively ,
It determines the method to call according to the type pointed to by the pointer . Even if we need to add several new classes in the future , We still call this method , This is the great charm of polymorphism .