Sa artikulong ito, tatalakayin namin ang lahat ng mga uri ng tagapagbuo na may mga halimbawa.
Halimbawa 1
Ito ay isang paglalarawan ng isang default na tagapagbuo. Tulad ng alam namin na ang mga tagapagbuo ay default na awtomatikong nilikha kapag lumikha kami ng isang bagay ng isang klase. Tinatawag itong implicit na paglikha. Ang mga tagabuo ay may parehong pangalan na ang pangalan ng klase. Isaalang-alang ang isang file na mayroong c ++ code ng tagapagbuo tulad ng alam namin na ang klase ay may dalawang pagpipilian, pribado at publiko. Naglalaman ang pribadong bahagi ng mga variable ng data, samantalang ang pampublikong bahagi ay para sa mga pagpapaandar na nakuha ng anumang bagay. Kaya't ang tagapagbuo ay tinukoy din sa pampublikong bahagi.
Integer()
{
x=limampu;
at=dalawampu;
};
Sa tagatayo na ito, ang mga halaga ay nakatalaga sa mga variable. Kung nais naming kunin ang mga halaga bilang isang output, kailangan nating i-print ang mga ito sa pangunahing programa.
Matapos tukuyin ang tagapagbuo, ang klase ay sarado. Habang papasok sa pangunahing programa, kukunin namin ang pag-print ng mga halaga sa pamamagitan ng paggamit ng isang object. Palaging ina-access ng object ang mga konstruktor dahil ito ang mga bahagi ng klase. Napakadali ng paggawa ng object. Ginagawa ito sa pamamagitan ng pagpapakilala nito sa pangalan ng klase. Iyon ay isang integer sa halimbawang ito. Ang halaga ay kukuha sa pamamagitan ng pamamaraan ng tuldok. ibig sabihin, a.x.
Maaari naming makita ang output ng source code mula sa terminal sa Ubuntu. Ang diskarte na ginamit para sa pagkuha ng output ay medyo madali. Una ang code ay naipon, at pagkatapos ito ay naisakatuparan. Ginagamit namin ang tagatala ng G ++ para sa proseso ng pagtitipon. Tulad din sa kaso ng C, gumagamit kami ng GCC.
$ G++ -o filec filec.c
./filec
-O ay ginagamit upang i-save ang output sa file.
Halimbawa 2
Sa ilustrasyong ito, ipapaliwanag namin ang mga parameterized konstruktor. Hindi tulad ng nakaraang halimbawa, maaari din nating ipasa ang mga argumento sa mga nagtayo mula sa pangunahing programa. Kapag nabuo ang bagay, ang mga halagang ito ay awtomatikong ipinapasa sa mga variable na naroroon sa tagapagbuo upang matanggap ang halaga. Ang ilan sa mga paggamit ng mga parameterized konstruktor ay.
- Ginagamit ito upang simulan ang iba't ibang mga variable na may iba't ibang mga halaga sa loob ng mga tagapagbuo kapag ito ay naisasimulan.
- Ginagamit ito sa overloading ng konstruktor. Ito ay tinukoy mamaya sa artikulo.
Isaalang-alang natin ngayon ang ilustrasyong inilarawan natin upang dagdagan ang konseptong ito. Ang klase ay may pangalan na integer, kaya sigurado, ang pangalan ng taga-buo ay magiging pareho. Sa mga parameter ng tagapagbuo, mayroong dalawang mga halaga ng uri ng integer. Nasisimulan ang mga ito upang tanggapin ang mga halagang ipinapadala mula sa pangunahing programa bilang isang tawag sa pag-andar.
Integer( intx,intat){
SA=x;
B=at;
};
Sa nakaraang halimbawa, ang mga variable sa loob ng tagapagbuo ay binigyan ng mga halaga. Samantalang sa tagabuo na ito, ang mga variable ay nakatalaga sa mga variable na may halaga.
Kung nais naming ipakita, kailangan naming tukuyin ang isang pagpapaandar na ibabalik ang halaga dahil hindi posible na ma-access ang inisyal na variable na direkta mula sa tagapagbuo.
intgetX(){
bumalik kasa;
};
Ngayon makikita natin ang pangunahing bahagi ng programa. Dito kapag nilikha ang bagay, maaari mong makita ang mga halaga sa seksyon ng parameter.
Integer v(70,55); {nagpapahiwatig}integer v=integer(10,labinlimang); {tahasang}
At upang ipakita ang resulta, tatawagin namin ang mga pagpapaandar na nilikha sa loob ng klase sa pamamagitan ng paggamit ng object. ibig sabihin v.getx ().
Ang pamamaraan ng pagkuha ng rekord ay pareho ng ipinakilala dati.
Halimbawa 3
Ang halimbawang ito ay nakikipag-usap sa pagkopya ng isang tagabuo ng isang klase. Ginagamit ang isang nakopya na tagapagbuo upang simulan ang bagay sa ibang bagay ng isang katulad na klase na kinabibilangan nito. Kinokopya ng tagapagbuo na ito ang data na naroroon sa isang bagay sa isa pa. Ang mga parameter ng tagatayo na ito ay naglalaman ng address ng isang object ng klase. Isaalang-alang ang mga naibigay na halimbawa, kung saan ipinakilala namin ang dalawang variable ng magkatulad na mga uri ng data upang maaari itong ma-access ng anumang pagpapaandar sa loob ng klase. Tumatanggap ang tagapagbuo ng mga halaga sa pamamagitan ng variable. Sa parehong oras, ang nakopya na tagapagbuo ay tatanggap lamang ng bagay. At sa tulong ng bagay na ito, makukuha ang mga halaga.
Pader(pader&obj){
Haba=objhaba;
Taas=objtaas;
}
Kailangan nating kalkulahin ang lugar, kaya ang pag-andar para sa pagkalkula na ito ay tinukoy dito. Ibabalik nito ang halaga sa pangunahing pag-andar kapag ito ay tinawag. Ngayon ay obserbahan namin ang pangunahing programa ng code
Ang tawag sa pagpapaandar ng nakopya na tagapagbuo ay magiging katulad nito.
Wall pader2=pader1;Tinatawag ng object ang nakopya na tagapagbuo, at ang data sa pamamagitan ng unang bagay ay nakopya sa pamamagitan nito. Bukod dito, tatawagin namin ang pagpapaandar upang makalkula ang lugar sa pamamagitan ng parehong mga object.
Mula sa output, maaari mong tingnan na ang resulta mula sa parehong mga tagapagbuo ay pareho. Nangangahulugan ito na ang buong data ay matagumpay na nakopya ng object.
Halimbawa 4
Ito ay isang paglalarawan ng overloading ng konstruktor. Nangyayari ito kapag kailangan naming gumamit ng higit sa isang solong pag-andar sa loob ng klase. Sinusunod ng overloading ng konstruktor ang mga tagubilin ng mga parameterized konstruktor. Ang lahat ng mga nagtayo sa klase ay may katulad na pangalan sa klase. Ngunit ang bawat isa sa mga nagtayo ay nakatalaga ng iba't ibang mga parameter. Ang bawat tagapagbuo ay tinatawag ayon sa argumento kapag nilikha namin ang bagay.
Isaalang-alang ang ibinigay na isang halimbawa, kung saan gumamit kami ng tatlong mga tagapagbuo. Ang isa ay walang anumang pagtatalo. Ang pangalawa ay may isang solong pagtatalo, samantalang ang pangatlo ay may dalawang argumento. Ang ilustrasyong ito ay katulad ng naunang isa. Habang kinakalkula namin ang lugar sa magkakahiwalay na pagpapaandar na inilarawan sa loob ng klase.
// Tagabuo na may dalawang argumentoHugis(intx,intat)
{
sa=x;
b=at;
};
Ngayon, paglipat patungo sa pangunahing programa, maaari naming makita na kapag pinasimulan natin ang object ng klase, ang tagapagbuo na walang argument ay tinawag bilang default. Ngayon kailangan naming tumawag sa iba pang mga tagapagbuo na may iba't ibang mga bagay na may iba't ibang mga argumento.
Hugis s;Hugis s2(8);
Hugis s3(4,2);
Ang pagpapaandar kung saan maaari nating ipakita ang halaga ay tinawag sa pamamagitan ng parehong bagay na nilikha.
Upang matingnan ang output, gagamitin namin ang parehong pamamaraan ng terminal ng utos sa pamamagitan ng pag-iipon at pagpapatupad ng code na naroroon sa file.
Mula sa output, maaari nating tingnan na ang sagot ay pareho para sa bawat tagapagbuo.
Konklusyon
Sa tutorial na ito, nakita namin ang mga pangunahing kaalaman sa mga tagapagbuo at kanilang mga pag-andar, kasama ang kung paano mag-overload ang mga ito. Ang mga tagabuo ay ginagamit upang simulan ang mga variable na may mga halaga.