Syntaxis
De foutmelding van onze fout is als volgt:
fout : kan de variabele ‘ ’ niet verklaren van het abstracte type ‘’Merk op dat er tussen lege haakjes variabele en abstracte klassenamen zullen zijn.
fout C2259 : 'Staat' : kan geen abstracte klasse instantiëren
Dit is een ander bericht dat we van de compiler krijgen als we zo'n fout tegenkomen.
Voorbeeld # 01:
Om deze fout begrijpelijk te maken, zullen we een voorbeeld uitvoeren waarin we onze code zo zullen schrijven dat we een foutmelding krijgen. Voor dat doel hebben we een klasse geïnitialiseerd met de naam 'ShapeClass'. Om deze klasse abstract te maken, hebben we er een virtuele functie in gedeclareerd met de naam 'getArea'. We hebben ook twee andere functies gedeclareerd met respectievelijk de namen 'setWidth' en 'setHeight'. Wat we hier willen doen, is dat we Hoogte als parameter en breedte als invoerparameter willen krijgen. We gaan de oppervlakte berekenen met behulp van onze invoerparameters. We hebben een instantie van onze klasse gemaakt in de hoofdmethode. Met behulp van dat object hebben we de methoden aangeroepen en zullen we de invoerparameters doorgeven via die methoden. Daarna hebben we onze uitvoer afgedrukt om de resultaten te controleren.
#include
namespace std; gebruiken ;
klasse VormKlasse
{
openbaar :
virtueel int Getaria ( ) = 0 ;
leegte setBreedte ( int in )
{
breedte = in ;
}
leegte setHoogte ( int h )
{
hoogte = h ;
}
beschermd :
int breedte ;
int hoogte ;
} ;
int hoofd ( leegte )
{
ShapeClasssh ;
sch. setBreedte ( 1 ) ;
sch. setHoogte ( twee ) ;
cout << 'Totale oppervlakte rechthoek: ' << sch. Getaria ( ) << eindel ;
opbrengst 0 ;
}
Het systeem gaf ons een foutmelding na het uitvoeren van onze code. De foutmelding zegt dat we variabele 'sh' niet kunnen declareren als abstract type 'shapeclass'. Nu probeert de compiler over te brengen dat 'ShapeClass' een abstract type is en dat we de variabele niet kunnen declareren. Dus met het bericht kunnen we duidelijk begrijpen dat de compiler ons onze abstracte klasse niet laat instantiëren, daarom geeft het systeem ons de fout.
Om de fout op te lossen, hebben we een andere klasse 'Rechthoek' gedeclareerd. Deze klasse wordt de onderliggende klasse van onze abstracte klasse en we zullen de body van onze virtuele functie in deze klasse declareren. Daarna zullen we het object in de hoofdmethode maken en met behulp van het object zullen we de functies aanroepen.
Na de wijzigingen hebben we onze code gemaakt en we zijn nu succesvol in het uitvoeren van onze code. Het systeem heeft onze code uitgevoerd zonder fouten te geven. We kunnen in de uitvoer zien dat het systeem de oppervlakte van een rechthoek heeft berekend en de uitvoer heeft afgedrukt. We hebben geleerd dat onze fout was dat we rechtstreeks het object van onze abstracte klasse noemden, wat de verkeerde benadering was. Toen we het object van zijn onderliggende klasse noemden, begon onze code goed te werken.
Voorbeeld # 02:
In dit voorbeeld gaan we geen wiskundige berekeningen uitvoeren. Dit voorbeeld is een generiek voorbeeld dat ons zal helpen abstracte klassen te begrijpen en hoe de compiler tussen de methoden en klassen draait tijdens het uitvoeren van de code. In deze klasse hebben we een abstracte klasse gemaakt en deze 'AbsClass' genoemd. We hebben een andere klasse 'ChildClass' verklaard, maar deze is geen abstracte klasse. Deze klasse is afgeleid van onze abstracte klasse.
We hebben 'Waarde doorgegeven met behulp van object' afgedrukt in een methode die is gedeclareerd in de abstracte klasse. De naam van de functie is 'valueFunc'. Zoals we hebben besproken, wordt de body van de virtuele functie gedeclareerd in de child-klasse. In onze kindklasse hebben we 'In virtuele functie' afgedrukt in onze virtuele functie-body. Nu zullen we een waarde doorgeven aan onze waardefunctie en kijken of de bereikte waarde correct is. In onze hoofdmethode hebben we een instantie van onze abstracte klasse gemaakt en met behulp van de instantie zullen we onze virtuele en andere functies noemen. Nu gaan we onze code uitvoeren.
#includenamespace std; gebruiken ;
klasse AbsKlasse
{
openbaar :
virtueel int VirtFunc ( ) = 0 ;
leegte waardeFunc ( int in )
{
breedte = in ;
cout << 'Waarde doorgegeven met object' << in << eindel ;
}
beschermd :
int breedte ;
} ;
klasse KindKlasse :
openbare AbsClass
{
openbaar :
int VirtFunc ( ) {
cout << 'In virtuele functie' << eindel ;
}
} ;
int hoofd ( leegte )
{
Kindklasse cc ;
cc. waardeFunc ( 5 ) ;
cout << cc. VirtFunc ( ) << eindel ;
opbrengst 0 ;
}
Na het uitvoeren van onze code krijgen we een foutmelding. Deze fout is eigenlijk dat we geen abstracte klasse kunnen instantiëren die we hier in onze hoofdmethode proberen te doen. Een ding om op te merken is dat de variabele en het abstracte type in ons bericht zijn gewijzigd.
Nu zullen we proberen onze fout te verwijderen en onze code uit te voeren. Voor dat doel zullen we het object van onze kindklasse maken en de instantie ervan maken. Met behulp van die instantie zullen we zowel de virtuele als een andere methode in onze abstracte klasse aanroepen. Er zal ook worden gekeken of we toegang hebben tot de virtuele functie met behulp van de kindklasse of niet. Als we hierin slagen, kunnen we zeggen dat we toegang hebben gekregen tot de abstracte klasse met behulp van de afgeleide klasse.
Bij het uitvoeren van onze code heeft de compiler deze keer geen fout gegenereerd. In plaats daarvan heeft het systeem onze code met succes gecompileerd en ons de uitvoer gegeven. Laten we nu eens kijken naar de uitvoer. Het systeem heeft er 'Waarde doorgegeven met behulp van object' en '5' tegen afgedrukt. Omdat we er 5 hebben gehaald met onze instantie in de hoofdmethode. Daarna drukte het de regel af die we erom vroegen in onze virtuele functie.
Conclusie
In deze handleiding hebben we kritieke fouten besproken die programmeurs tegenkomen bij het coderen en oefenen van objectgeoriënteerde concepten. Dit soort fouten komen vaak voor wanneer een programmeur te maken heeft met abstracte klassen. Het hele artikel vat samen dat abstracte klassen niet kunnen worden geïnstantieerd en dat we hun objecten er geen methoden in kunnen laten aanroepen. We hebben ook verschillende voorbeelden geprobeerd om fouten te maken en hebben vervolgens de fouten in onze code opgelost.