En la substitució de funcions, la classe fill redefineix la funció que ja està definida a la seva classe pare.
Permet al programador proporcionar funcionalitats derivades específiques de classe (tot i que es defineix a la classe base).
Ara, veurem uns quants exemples i comprendreem el concepte de substitució de funcions a C ++.
Exemple-1
He definit dues classes al següent exemple de codi: una classe base i una classe derivada. La classe base té una funció membre, és a dir, disp (). La Derived_Class s’hereta de la Base_Class. La funció disp () és present a Base_Class i es redefineix a Derived_Class.
A la funció main (), es crea un objecte de Derived_Class, és a dir, d. A continuació, anomenem la funció disp () a l'objecte de classe derivada, de manera que s'invocarà la funció de la classe derivada. Aquí s’ignora la versió de la classe base. A continuació podeu veure la funció de sortida as - disp () a la classe derivada.
#incloureutilitzant l'espai de noms std;
// classe base
classe Base_Class
{
públic:
buitaprofitar()
{
cost<< 'funció disp () a la classe base.' <<endl;
}
};
// classe derivada
classe Derived_Class:Classe_Base pública
{
públic:
buitaprofitar()
{
cost<< 'funció disp () en classe derivada' <<endl;
}
};
intprincipal()
{
Classe_Derivada d;
d.aprofitar(); // funció disp () sobre objecte de classe derivat
tornar 0;
}
Exemple-2
En aquest exemple, veurem com anomenar deliberadament la versió de classe base de la funció mitjançant l'objecte de classe derivat. A la definició de la funció de classe derivada, fem servir l'operador de resolució d'abast [::] per anomenar la versió de classe base de la funció.
#incloureutilitzant l'espai de noms std;
classe Base_Class
{
públic:
buitaprofitar()
{
cost<< 'funció disp () a la classe base.' <<endl;
}
};
classe Derived_Class:Classe_Base pública
{
públic:
buitaprofitar()
{
Classe_base::aprofitar(); // Truqueu a la versió base de disp ()
}
};
intprincipal()
{
Classe_Derivada d;
d.aprofitar();
tornar 0;
}
Exemple-3
Aquest és un altre exemple de substitució de funcions. En aquest exemple, hem creat una classe pare - Animal i dues classes derivades - Duck and Dog. La classe base, és a dir, la classe Animal, té un so de funció membre ().
A la classe derivada / classe infantil, és a dir, Dog, hem redefinit la mateixa funció, és a dir, sound (), per anul·lar la seva definició de classe base. De la mateixa manera, a l’altra classe derivada, és a dir, Duck, hem redefinit la mateixa funció, és a dir, so ().
A la funció main (), hem creat l'objecte dog de Dog and duck of Duck. Per tant, ara, quan anomenem la funció sound () per a gos i ànec, es cridarà a la versió derivada de la funció sound (). Podeu veure la sortida del programa com es mostra a continuació. Per tant, amb l’ajut de la funció primordial, podem invocar la funció específica de classe derivada.
#incloureutilitzant l'espai de noms std;
classe Animal
{
públic:
buitso()
{
cost<< 'So animal!' <<endl;
}
};
// Classe derivada - Classe de gossos
classe Gos:Animal públic
{
públic:
buitso()
{
cost<< 'So de gos: escorça'. <<endl;
}
};
// Classe derivada: classe d'ànecs
classe Ànec:Animal públic
{
públic:
buitso()
{
cost<< 'So d'ànec: xarlatà'. <<endl;
}
};
intprincipal()
{
Gos de gos;
Ànec d'ànec;
gos.so(); // sound () de gos
ànec.so(); // sound () d'ànec
tornar 0;
}
Conclusió
En aquest article, he explicat la funció que substitueix a C ++ . El llenguatge C ++ admet polimorfisme en temps d'execució. La substitució de funcions ajuda a aconseguir el polimorfisme en temps d'execució en C ++. Aquest article analitzava el concepte de substitució de funcions i com aconseguir polimorfisme en temps d'execució mitjançant la substitució de funcions.