Paano Maipatupad ang Overloading ng Operator sa c ++?

Sa artikulong ito ay titingnan namin ang isa pang konsepto na nakatuon sa object na ginagawang madali ang paghawak ng operator. Iyon ay makukuha namin ang mga detalye ng Operator Overloading sa C ++ . Saklaw ang artikulong ito sa artikulong ito,

• Overloading sa C ++
• Mga uri ng labis na karga sa C ++
• Bakit ginagamit ang overloading ng operator?
• Pagpapatupad ng Overloading ng Operator sa C ++
• Mga uri ng mga overloading na diskarte
• Overloading Unary Operators
• Pag-overload ng Mga Binary Operator

Kaya, magsimula tayo sa artikulong ito sa Operator Overloading sa C ++.

Overloading sa C ++

Kung lumikha kami ng dalawa o higit pang miyembro ng parehong klase na may parehong pangalan ngunit magkakaiba sa bilang o uri ng parameter, kilala ito bilang C ++ overloading.

Sa C ++, maaari kaming mag-overload:

• paraan
• tagapagtayo
• na-index na mga pag-aari

Ito ay dahil ang mga miyembrong ito ay may mga parameter lamang.

Nagpapatuloy sa artikulong ito sa Operator Overloading sa C ++.

Mga uri ng labis na karga sa C ++

• Pag-o-overload ng pagpapaandar
• Sobra sa pagpapatakbo ng operator

Nagpapatuloy sa artikulong ito sa Operator Overloading sa C ++.

Bakit ginagamit ang overloading ng operator?

Ang mga programa ng C ++ ay maaaring maisulat nang walang kaalaman sa labis na pag-load ng operator. Pagkatapos din, ang pagpapatakbo ng operator ay malalim na ginamit ng mga programmer upang gawing intuitive ang programa. Halimbawa,

Maaari naming palitan ang code tulad ng:

pagkalkula = idagdag (hatiin (a, b), multiply (a, b))

Para sa equation

malabo na lohika sa artipisyal na katalinuhan

pagkalkula = (a / b) + (a * b)

Ang overloading ng operator ay nagbibigay ng isang simple at madaling paraan para sa pagbuo ng mga bagong kahulugan para sa karamihan ng mga operator sa C ++. Sa sapat na kaalaman, makakagawa tayo halos ng isang bagong wika ng aming sarili sa pamamagitan ng malikhaing paggamit ng mga diskarte sa pag-andar at pagpapatakbo ng operator. Maaari nating mai-overload ang lahat ng mga operator sa C ++ maliban sa sumusunod:
● Operator ng saklaw (: :)
● Laki ng operator (Sizeof)
● tagapili ng miyembro (.)
● miyembro pointer selector (*)
● ternary operator (? :)

Syntax ng Operator Overloading

kung paano simulan ang isang bagay sa sawa

return_type class_name:: op ng op (argument_list) {// function body}

Kung saan ang uri ng pagbabalik ay ang uri ng halagang ibinalik ng pagpapaandar. class_name ang pangalan ng klase.

Nagpapatuloy sa artikulong ito sa Operator Overloading sa C ++.

Pagpapatupad ng Overloading ng Operator sa C ++

Ang pagpapaandar ng operator ay dapat na alinman sa hindi static (pag-andar ng miyembro) o pag-andar ng kaibigan upang maging labis na karga. Ang pagpapaandar ng overloading ng operator ay maaaring mailapat sa isang pag-andar ng miyembro kung ang kaliwang operand ay isang bagay ng klase na iyon, ngunit kung ang Kaliwa na operand ay iba, kung gayon ang pagpapaandar ng labis na pag-load ng Operator ay dapat na tinukoy bilang isang hindi kasapi na pag-andar.
Ang pagpapaandar ng overloading ng operator ay maaaring gawing pagpapaandar ng kaibigan kung nangangailangan ito ng pag-access sa pribado at protektadong mga miyembro ng klase. Halimbawa, ang op ng operator ay isang pagpapaandar ng operator kung saan ang op ay ang operator na sobrang karga, at ang operator ay keyword. Ang overloading ng operator ay maaaring makamit sa pamamagitan ng pagpapatupad ng isang pagpapaandar na maaaring alinman sa pagpapaandar ng miyembro, pagpapaandar na hindi kasapi o pag-andar ng kaibigan.

Ano ang pagkakaiba sa pagitan ng mga pagpapaandar ng operator at normal na pag-andar?

Ang mga pagpapaandar ng operator ay kapareho ng normal na pag-andar. Ang pagkakaiba lamang ay, ang pangalan ng isang pagpapaandar ng operator ay palaging keyword ng operator na sinusundan ng simbolo ng mga pagpapaandar ng operator at operator ay tinawag kapag ginamit ang kaukulang operator.

Nagpapatuloy sa artikulong ito sa Operator Overloading sa C ++.

Mga uri ng mga overloading na diskarte

Ang Operator Overloading ay maaaring gawin sa pamamagitan ng paggamit ng tatlong mga diskarte, ang mga ito

• Overloading ang unary operator.
• Overloading binary operator.
• Overloading binary operator gamit ang isang pagpapaandar ng kaibigan.

Nagpapatuloy sa artikulong ito sa Operator Overloading sa C ++.

Overloading Unary Operator

Isaalang-alang natin ang unary ‘-‘ operator. Ang isang minus operator kapag ginamit bilang isang unary nangangailangan lamang ito ng isang operand. Alam namin na binago ng operator na ito ang pag-sign ng isang operand kapag inilapat sa isang pangunahing variable ng data. Tingnan natin kung paano mag-overload ang operator na ito upang mailapat ito sa isang bagay sa parehong paraan tulad ng paglalapat nito sa isang int o float variable. Ang unary minus, kapag inilapat sa isang bagay, dapat mabawasan ang bawat isa sa mga item ng data.

Halimbawa:

# isama ang paggamit ng namespace std class Taas {publiko: // Mga Miyembro ng Mga Bagay int paa, pulgada // Tagabuo upang simulan ang halaga ng Taas ng bagay (int f, int i) {talakayan = f pulgada = i} // Overloading (-) operator sa gumanap decrement // pagpapatakbo ng Height object void operator- () {feet-- inch-- cout<< 'Feet & Inches after decrement: ' << feet << ' ' ' << inch <
 Output: 
 Paliwanag:  
Sa halimbawa sa itaas, nag-o-overload kami ng ‘-’ unary operator upang maisagawa ang pagbawas sa dalawang variable ng Height class. Ipinapasa namin ang dalawang mga parameter sa tagapagbuo at i-save ang kanilang mga halaga sa mga paa at pulgada na variable. Pagkatapos ay tinukoy namin ang pagpapaandar ng overloading ng operator (void operator- () 
) kung saan ang dalawang variable ay nabawasan ng isang posisyon. 
Kapag nagsulat kami -h1 tinawag nito ang pagpapaandar ng labis na pag-andar ng operator at binabawasan ang mga halagang ipinasa sa tagapagbuo.
Nagpapatuloy sa artikulong ito sa Operator Overloading sa C ++.
 Pag-overload ng Binary Operator 
Ito ay isang labis na karga ng isang operator na tumatakbo sa dalawang mga operan. Gawin natin ang parehong halimbawa ng Taas ng klase, ngunit sa oras na ito, magdagdag ng dalawang mga Taas na bagay na h1 at h2.
tutorial ng developer ng salesforce para sa mga nagsisimula
 Halimbawa: 
# isama ang paggamit ng namespace std class Taas {publiko: int paa, pulgada Taas () {feet = 0 inch = 0} Taas (int f, int i) {feet = f inch = i} // Overloading (+) operator upang maisagawa pagdaragdag ng // dalawang distansya na bagay gamit ang binary operator Taas na operator + (Taas & d2) // Tumawag sa pamamagitan ng sanggunian {// Lumikha ng isang bagay upang ibalik ang Taas h3 // Magsagawa ng pagdaragdag ng mga paa at pulgada h3.feet = talampakan + d2.feet h3. pulgada = pulgada + d2.inch // Ibalik ang nagresultang object return h3}} int main () {Taas h1 (3, 7) Taas h2 (6, 1) Taas h3 // Gumamit ng sobrang karga na operator h3 = h1 + h2 cout<< 'Sum of Feet & Inches: ' << h3.feet << ''' << h3.inch << endl return 0 } 
 Output:  
 
 Paliwanag:  
Taas operator + (Taas & h2), narito ang pagbalik_type ng pagpapaandar ay klase Taas sa gayon ay nagbabalik ito ng isang bagay h3 ng Taas ng klase. Sa linya h3 = h1 + h2, tawag ng h1 ang pagpapaandar ng operator ng mga bagay sa klase nito at kukuha ng h2 bilang isang parameter, pagkatapos ay inilalapat namin ang h3.feet = talampakan + d2.feet at h3.inch = pulgada + d2.inch na naglalagay ng kabuuan ng mga halaga ng mga variable na paa at pulgada sa mga variable na nauugnay sa h3 na bagay. 
Kapag ang pahayag na 'h3 = h1 + h2' ay nag-aanyaya sa labis na pag-andar ng operator ang object h1 ang kumuha ng responsibilidad na tawagan ang pagpapaandar at gampanan ng h2 ang papel na ginagawang argumento na ipinapasa sa pagpapaandar. Ang pahayag sa itaas na paanyaya ay katumbas ng h3 = h1.operator + (h2) samakatuwid ang miyembro ng data ng h2 ay direktang na-access at ang kasapi ng data ng h2 (na naipasa bilang isang argument) ay na-access gamit ang dot operator.
 Mga Panuntunan para sa Overloading ng Operator 
Ang mayroon nang mga operator ay maaaring mag-overload at ang mga bagong operator ay hindi maaaring mag-overload
Ang sobrang karga na operator ay dapat maglaman ng kahit isang operand ng uri ng data na tinukoy ng gumagamit.
Hindi kami gumagamit ng isang pag-andar ng kaibigan upang mag-overload ng ilang mga operator. Gayunpaman, ang mga pagpapaandar ng miyembro ay maaaring magamit upang mag-overload ang mga operator na iyon.
Kapag ang mga unary operator ay overloaded sa pamamagitan ng pag-andar ng miyembro ay hindi sila kumuha ng mga malinaw na argumento, ngunit, kung ang mga ito ay sobrang karga ng isang pagpapaandar ng kaibigan kumuha sila ng isang pagtatalo.
Kapag ang mga binary operator ay labis na na-overload sa pamamagitan ng pag-andar ng miyembro ay kumuha sila ng isang tahasang argumento, at kung ang mga ito ay sobrang karga sa pamamagitan ng pag-andar ng kaibigan kumuha sila ng dalawang malinaw na argumento.
Sa gayon ay natapos na kami sa artikulong ito sa 'Operator Overloading in C ++'. Kung nais mong matuto nang higit pa, tingnan ang Java Training ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Edureka’s  ang kurso ay idinisenyo upang sanayin ka para sa parehong core at advanced na konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.
 May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na ito at babalikan ka namin sa lalong madaling panahon.