Quelle est la différence entre une fonction virtuelle et une fonction virtuelle pure ?

La différence entre les fonctions virtuelles et les fonctions virtuelles pures : 1. Les fonctions virtuelles pures n'ont que des définitions et aucune implémentation ; les fonctions virtuelles ont à la fois des définitions et des codes d'implémentation ; 2. Une classe contenant des fonctions virtuelles pures ne peut pas définir ses objets, mais une classe contenant des fonctions virtuelles le peut.

Recommandations associées : "Tutoriel vidéo C++"

Fonction virtuelle (virtuelle impure)

La fonction principale de la fonction virtuelle de C++ est le "polymorphisme d'exécution". La classe parent fournit l'implémentation de la fonction virtuelle et fournit l'implémentation de fonction par défaut pour la sous-classe.
Les sous-classes peuvent remplacer les fonctions virtuelles de la classe parent pour réaliser la spécialisation de la sous-classe.
Ce qui suit est une fonction virtuelle dans une classe parent :

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

Fonction virtuelle pure (virtuelle pure)

Une classe en C++ qui contient des fonctions virtuelles pures est appelé C'est une "classe abstraite". Les classes abstraites ne peuvent pas utiliser new pour créer des objets. Seules les sous-classes qui implémentent cette fonction virtuelle pure peuvent créer de nouveaux objets.
La fonction virtuelle pure en C++ ressemble plus à "fournir uniquement des déclarations, pas d'implémentation", c'est une contrainte sur les sous-classes et c'est un "héritage d'interface".
Les fonctions virtuelles pures en C++ sont aussi une sorte de "polymorphisme d'exécution".
Par exemple, la classe suivante contient des fonctions virtuelles pures, qui est une "classe abstraite" :

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

Par exemple,

#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();//调用派生类的 
}

Fonctions virtuelles et fonctions virtuelles pures Les différences

1) Les fonctions virtuelles pures n'ont que des définitions et aucune implémentation tandis que les fonctions virtuelles ont à la fois des définitions et des codes d'implémentation ;

Les fonctions virtuelles pures n'ont généralement pas de partie d'implémentation de code, comme virtual void print() = 0; 2） et les fonctions virtuelles générales doivent avoir une partie d'implémentation de code, sinon une erreur de fonction non définie se produira.

2) Une classe contenant des fonctions virtuelles pures ne peut pas définir ses objets, mais une classe contenant des fonctions virtuelles le peut.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!