Syntax
Ang mensahe ng error ng aming error ay ang mga sumusunod:
pagkakamali : hindi maipahayag ang variable na ' ' na may abstract na uri'Tandaan na sa walang laman na panaklong, magkakaroon ng variable at abstract na mga pangalan ng klase.
error C2259 : 'estado' : hindi makapag-instantiate ng abstract na klase
Ito ay isa pang mensahe na nakukuha namin mula sa compiler kapag nakatagpo kami ng ganoong error.
Halimbawa # 01:
Upang gawing maliwanag ang error na ito, magsasagawa kami ng isang halimbawa kung saan isusulat namin ang aming code sa paraang makakakuha kami ng error. Para sa layuning iyon, nagpasimula kami ng isang klase na may pangalang 'ShapeClass'. Upang gawing abstract ang klase na ito, nagdeklara kami ng virtual function dito na may pangalang 'getArea'. Nagdeklara kami ng dalawang iba pang mga function pati na rin ang mga pangalan na 'setWidth' at 'setHeight' ayon sa pagkakabanggit. Ang gusto naming gawin dito ay gusto naming makuha ang Taas bilang parameter at lapad bilang input parameter. Kakalkulahin namin ang lugar sa tulong ng aming mga parameter ng input. Gumawa kami ng isang instance ng aming klase sa pangunahing paraan. Sa tulong ng bagay na iyon, tinawag namin ang mga pamamaraan at ipapasa namin ang mga parameter ng input sa mga pamamaraang iyon. Pagkatapos nito, nai-print namin ang aming output upang suriin ang mga resulta.
#include
gamit ang namespace std ;
klase ShapeClass
{
pampubliko :
virtual int Getaria ( ) = 0 ;
walang bisa setWidth ( int sa )
{
lapad = sa ;
}
walang bisa setHeight ( int h )
{
taas = h ;
}
protektado :
int lapad ;
int taas ;
} ;
int pangunahing ( walang bisa )
{
ShapeClasssh ;
sh. setWidth ( 1 ) ;
sh. setHeight ( dalawa ) ;
cout << 'Kabuuang Rectangle area: ' << sh. Getaria ( ) << endl ;
bumalik 0 ;
}
Ang system ay nagbigay sa amin ng isang error pagkatapos ng pagpapatupad ng aming code. Ang mensahe ng error ay nagsasabi na hindi namin maaaring ideklara ang variable na 'sh' na may abstract na uri na 'shapeclass'. Ngayon, sinusubukan ng compiler na ipahiwatig na ang 'ShapeClass' ay isang abstract na uri at hindi namin maipahayag ang variable nito. Kaya, sa mensahe, malinaw nating mauunawaan na hindi tayo hinahayaan ng compiler na i-instantiate ang abstract class natin kaya naman binibigyan tayo ng system ng error.
Upang malutas ang error, nagdeklara kami ng isa pang klase na 'Rectangle'. Ang klase na ito ang magiging child class ng abstract class namin at idedeklara namin ang body ng aming virtual function sa klase na ito. Pagkatapos nito, lilikha tayo ng object nito sa pangunahing pamamaraan at sa tulong ng object nito, tatawagin natin ang mga function.
Pagkatapos ng mga pag-amyenda, ginawa namin ang aming code at ngayon ay naging matagumpay na kami sa pagpapatakbo ng aming code. Naisagawa ng system ang aming code nang hindi nagbibigay ng mga error. Makikita natin sa output na kinakalkula ng system ang lugar ng isang parihaba at nai-print ang output. Nalaman namin na ang aming pagkakamali ay direktang tinawag namin ang object ng aming abstract na klase na maling diskarte. Noong tinawag namin ang object ng child class nito, nagsimulang gumana nang maayos ang aming code.
Halimbawa # 02:
Sa halimbawang ito, hindi kami gagawa ng anumang mga kalkulasyon sa matematika. Ang halimbawang ito ay isang generic na halimbawa na makakatulong sa amin na maunawaan ang mga abstract na klase at kung paano tumatakbo ang compiler sa pagitan ng mga pamamaraan at klase habang isinasagawa ang code. Sa klase na ito, gumawa kami ng abstract na klase at pinangalanan itong 'AbsClass'. Nagdeklara kami ng isa pang klase na 'ChildClass' ngunit ang isang ito ay hindi isang abstract na klase. Ang klase na ito ay hango sa aming abstract na klase.
Nag-print kami ng 'Value na naipasa gamit ang Object' sa isang paraan na idineklara sa abstract na klase. Ang pangalan ng function ay 'valueFunc'. Tulad ng aming tinalakay, ang katawan ng virtual na function ay idineklara sa klase ng bata. Sa aming child class, nag-print kami ng 'In virtual function' sa aming virtual function body. Ngayon, magpapasa tayo ng value sa ating value function at tingnan kung tama ang value na naabot. Sa aming pangunahing pamamaraan, lumikha kami ng isang halimbawa ng aming abstract na klase at sa tulong ng halimbawa, tatawagin namin ang aming virtual at iba pang mga function. Ngayon, isasagawa namin ang aming code.
#includegamit ang namespace std ;
klase AbsClass
{
pampubliko :
virtual int VirtFunc ( ) = 0 ;
walang bisa valueFunc ( int sa )
{
lapad = sa ;
cout << 'Nakapasa ang value gamit ang Object' << sa << endl ;
}
protektado :
int lapad ;
} ;
klase ChildClass :
pampublikong AbsClass
{
pampubliko :
int VirtFunc ( ) {
cout << 'Sa Virtual Function' << endl ;
}
} ;
int pangunahing ( walang bisa )
{
ChildClass cc ;
cc. valueFunc ( 5 ) ;
cout << cc. VirtFunc ( ) << endl ;
bumalik 0 ;
}
Pagkatapos ng execution ng aming code, magkakaroon kami ng error. Ang error na ito ay karaniwang hindi namin mai-instantiate ang isang abstract na klase na sinusubukan naming gawin dito sa aming pangunahing pamamaraan. Isang bagay na dapat tandaan dito ay ang variable at abstract na uri sa aming mensahe ay binago.
Ngayon, susubukan naming alisin ang aming error at isagawa ang aming code. Para sa layuning iyon, gagawa kami ng object ng aming child class at gagawin itong instance. Sa tulong ng pagkakataong iyon, tatawagin natin ang parehong virtual at isa pang pamamaraan sa ating abstract na klase. Mapapansin din kung maa-access natin ang virtual function gamit ang child class o hindi. Kung tayo ay matagumpay sa paggawa nito, masasabi nating na-access natin ang abstract na klase gamit ang nagmula nitong klase.
Sa pagpapatupad ng aming code, ang compiler ay hindi naghagis ng anumang error sa oras na ito. Sa halip, matagumpay na naipon ng system ang aming code at ibinigay sa amin ang output. Ngayon, tingnan natin ang output. Nag-print ang system ng 'Value passed using Object' at '5' laban dito. Dahil nakapasa kami sa 5 gamit ang aming halimbawa sa pangunahing pamamaraan. Pagkatapos nito, na-print nito ang linya na hiniling namin dito sa aming virtual function.
Konklusyon
Sa gabay na ito, tinalakay namin ang mga kritikal na error na nararanasan ng mga programmer habang nagko-coding at nagsasanay ng mga object-oriented na konsepto. Ang mga ganitong uri ng mga error ay madalas na nangyayari kapag ang isang programmer ay nakikitungo sa mga abstract na klase. Ang buong artikulo ay nagbubuod na ang mga abstract na klase ay hindi maaaring ma-instantiate, at hindi namin maaaring gawin ang kanilang mga object na tawagan ang mga pamamaraan dito. Sinubukan din namin ang iba't ibang mga halimbawa upang lumikha ng mga error at pagkatapos ay nalutas ang mga error sa aming code.