Was ist der Unterschied zwischen einer virtuellen Funktion und einer rein virtuellen Funktion?

Der Unterschied zwischen virtuellen Funktionen und rein virtuellen Funktionen: 1. Reine virtuelle Funktionen haben nur Definitionen und keine Implementierung, während virtuelle Funktionen sowohl Definitionen als auch Implementierungscodes haben. 2. Eine Klasse, die rein virtuelle Funktionen enthält, kann ihre Objekte nicht definieren, eine Klasse, die virtuelle Funktionen enthält, jedoch schon.

Verwandte Empfehlungen: „C++-Video-Tutorial“

virtuelle Funktion (unrein virtuell)

　Die Hauptfunktion virtueller C++-Funktionen ist „Laufzeitpolymorphismus“, und die Implementierung virtueller Funktionen wird in bereitgestellt die übergeordnete Klasse, die Standardfunktionsimplementierungen für Unterklassen bereitstellt.
　 Unterklassen können die virtuellen Funktionen der übergeordneten Klasse überschreiben, um eine Spezialisierung der Unterklasse zu erreichen.
Das Folgende ist eine virtuelle Funktion in einer übergeordneten Klasse:

class A
{
public:
     virtual void ss()
    {
        cout<<"我是基类的虚函数"<<endl;
    }
};

Reine virtuelle Funktion (rein virtuell)

Eine Klasse in C++, die rein virtuelle Funktionen enthält, wird als „abstrakte Klasse“ bezeichnet. Abstrakte Klassen können new nicht zum Erstellen von Objekten verwenden. Nur Unterklassen, die diese rein virtuelle Funktion implementieren, können neue Objekte erstellen.
　　Die rein virtuelle Funktion in C++ ähnelt eher „nur Bereitstellung von Deklarationen, keine Implementierung“, sie stellt eine Einschränkung für Unterklassen dar und ist „Schnittstellenvererbung“.
　Rein virtuelle Funktionen in C++ sind auch eine Art „Laufzeitpolymorphismus“.
　Zum Beispiel enthält die folgende Klasse reine virtuelle Funktionen, bei denen es sich um eine „abstrakte Klasse“ handelt:

class A
{
public:
    virtual void out1(string s)=0;  //我是基类的虚函数 
};

Zum Beispiel

#include<iostream>
#include<string>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
class a
{
	private:
	
	public:
		a(){      //构造函数用内联函数的形式 
			
		}
		//虚函数 
		virtual  void  xhs(){   	   //这个虚函数必须得在基类中实现 
			cout<<"我是基类的虚函数"<<endl;//即使是空的虚函数也要在基类中实现 
		}  //派生类中可以不写这个函数，但是派生类对象调用时会调用积累的虚函数 
		
		//纯虚函数 
		virtual void cxhs() =0;  //这个纯虚函数不在基类中实现，必须在子类中实现 
		
}; 
class b:public a
{
	private:
		
    public:
    	void xhs(){         //这个是可有可无的 
    		cout<<"我是派生类覆盖基类虚函数的函数"<<endl; 
		}                        //*
		                         //*
		void cxhs(){         //这个是必须有实现的 
			cout<<"我是派生类覆盖基类虚函数的函数"<<endl; 
		}       //*              //*
}; 				//* 			 //*
int main()      //*              //*
{               //*              //*
	b c;        //*              //* 
	c.xhs();    //*           //调用派生类的 
	c.cxhs();//调用派生类的 
}

Der Unterschied zwischen virtuellen Funktionen und rein virtuellen Funktionen

1) Nur reine virtuelle Funktionen haben Definitionen und keine Implementierungen; Und virtuelle Funktionen haben sowohl Definitionen als auch Implementierungscodes.

Reine virtuelle Funktionen haben im Allgemeinen keinen Code-Implementierungsteil, wie z. B. virtual void print() = 0; 2）Allgemeine virtuelle Funktionen müssen einen Code-Implementierungsteil haben, sonst tritt ein undefinierter Funktionsfehler auf.

2) Eine Klasse, die rein virtuelle Funktionen enthält, kann ihre Objekte nicht definieren, eine Klasse, die virtuelle Funktionen enthält, jedoch schon.

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen einer virtuellen Funktion und einer rein virtuellen Funktion?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!