Ang mga interface sa C++ ay inilapat gamit ang mga abstract na klase. Sa kabilang banda, ang isang klase ay tinatawag na isang abstract na klase kung hindi bababa sa isang function sa loob ng isang klase ay idineklara bilang isang purong virtual function.
Ano ang Pure Virtual Function
Ang Purong Virtual Function nangangahulugan na ang mga gumagamit ay nagdedeklara lamang ng pag-andar at hindi ang kahulugan nito. Ginagamit ang method/function overriding para ipatupad ang mga purong virtual na pamamaraan sa nagmula na klase. Ang isang function ay itinuturing na purong virtual kung ito ay inilarawan sa loob ng klase tulad ng ibinigay sa ibaba:
Narito ang syntax ng a Purong Virtual Function ng Class Room.
klase Kwarto {
pampubliko :
// purong virtual function
virtual doble Getaria ( ) = 0 ;
pribado :
doble haba ; // Haba ng isang Kwarto
doble Lapad ; // Lapad ng isang Kwarto
} ;
Ano ang Abstract Class
Ang isang klase na partikular na nilikha para sa layunin ng pagsisilbi bilang isang batayang klase ay pinangalanang an abstract na klase . Dapat na mayroong kahit isang purong virtual function sa abstract na klase. Maaaring kabilang dito ang mga variable at karaniwang function. Ang mga nagmula na klase na mayroon ang abstract na klase, ay dapat magpatupad ng isang purong virtual function ng base class, kung hindi, sila ay magiging abstract.
Isaalang-alang ang sumusunod na halimbawa, kung saan ang parent class ay nagbibigay ng interface sa isang base class upang ang base class ay maglapat ng purong virtual function na tinatawag getArea() . Dalawang magkaibang klase ang gumagamit ng pareho getArea() function, ngunit ang output para sa parehong mga kaso ay magkakaiba.
#include
gamit namespace std ;
klase Hugis
{
pampubliko :
virtual int Getaria ( ) = 0 ;
walang bisa setWidth ( int wth )
{
lapad = wth ;
}
walang bisa setLength ( int lth )
{
haba = lth ;
}
protektado :
int lapad ;
int haba ;
} ;
klase Parihaba : pampubliko Hugis
{
pampubliko : int Getaria ( )
{
bumalik ( lapad * haba ) ;
}
} ;
klase Tatsulok : pampubliko Hugis
{
pampubliko : int Getaria ( )
{
bumalik ( lapad * haba ) / 2 ;
}
} ;
int pangunahing ( walang bisa )
{
Parihaba R ;
Triangle T ;
R. setWidth ( 9 ) ;
R. setLength ( 5 ) ;
cout << 'Lugar ng Parihaba: ' << R. Getaria ( ) << endl ;
T. setWidth ( 9 ) ;
T. setLength ( 5 ) ;
cout << 'Lugar ng Triangle:' << T. Getaria ( ) << endl ;
bumalik 0 ;
}
Output
Kahalagahan ng Mga Interface
Anumang klase na nagmula sa isang purong abstract na klase (Interface) ay dapat palaging ipatupad ang bawat isa sa mga pamamaraan ng base class, ibig sabihin, Interface. Ang mga pointer ng interface ay maaaring maipasa sa mga function pati na rin sa mga klase, na nagpapahintulot sa amin na tawagan ang mga function ng nagmula na klase mula doon mismo.
Ano ang Mga Panuntunan sa Paggamit ng Mga Interface
May mga sumusunod na panuntunang dapat sundin ng mga user para sa paggamit ng mga interface sa C++:
- Ideklara lamang ang mga purong virtual function.
- 0 lang ang itinalaga sa mga purong virtual function.
- Huwag gumawa ng interface ng mga klase.
- Gamit ang isang reference sa isang base abstract class, maaari tayong lumikha ng isang pointer sa isang instance ng nagmula na klase.
Sa sumusunod na code, isang interface linuxhint , tulad ng isang abstract na klase ay nilikha sa pamamagitan ng paggamit ng isang purong virtual na pamamaraan, pati na rin ang pag-andar nito ay inilapat sa klase ng bata, at tinawag namin ang returnString() paraan sa pangunahing pag-andar sa pamamagitan ng pagsunod sa mga panuntunan sa interface.
#include#include
#include
gamit namespace std ;
klase linuxhint
{
pampubliko :
virtual string returnString ( ) = 0 ;
} ;
klase anak : pampubliko linuxhint
{
pampubliko :
string returnString ( )
{
bumalik 'Hello Linuxhint' ;
}
} ;
int pangunahing ( )
{
bata bata_bagay ;
linuxhint * pntr ;
pntr = at bata_bagay ;
cout < returnString ( ) ;
bumalik 0 ;
}
Output
Konklusyon
Ang mga interface ay mga abstract na klase na naglalarawan sa gawi ng klase na nangangailangan upang ipatupad ang kinakailangang klase sa C++. Ang mga nabanggit na alituntunin ay mahalaga para sa isang baguhan na mapabuti ang kanilang mga kasanayan sa programming sa C++ sa pamamagitan ng pagtatrabaho sa mga interface. Makakakita ka rin ng ilang halimbawa na makakatulong sa iyong matutunan ang pagpapatupad ng mga interface sa C++.