Pag-o-overload ng pagpapaandar sa C ++: Lahat ng Kailangan Mong Malaman

Magbibigay sa iyo ang artikulong ito ng isang detalyado at komprehensibong kaalaman tungkol sa Pag-o-overload ng Function sa C ++ na may maraming mga Halimbawa na mauunawaan.

Ang C ++ ay isa sa mga wika ng pagprograma na napaka-kakayahang umangkop at sumasaklaw din ito ng maraming mga tampok ng programa na nakatuon sa object. Ang labis na pag-load ay isa pang tampok ng wikang ito sa pagprograma.Saklaw ang mga sumusunod na Turo sa artikulong 'Pag-o-overload ng Function sa C ++' na artikulo-



C ++ Overloading

Kapag lumikha kami ng dalawa o higit pang mga miyembro ng isang klase na may parehong pangalan ngunit magkakaiba sa bilang o uri ng mga parameter, kilala ito bilang C ++ overloading. Sa C ++, maaari kaming mag-overload:



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

Mga uri ng labis na karga sa C ++

types-of-overloading-in-c++

Ano ang overloading ng pag-andar sa C ++?

Ang Pag-overload ng pagpapaandar sa C ++ ay maaaring tukuyin bilang proseso ng pagkakaroon ng dalawa o higit pang mga pagpapaandar ng miyembro ng isang klase na may parehong pangalan, ngunit magkakaiba sa mga parameter. Sa pag-overload ng pag-andar, ang function ay maaaring muling tukuyin alinman sa pamamagitan ng paggamit ng iba't ibang mga uri ng mga argumento o isang iba't ibang mga numero ng mga argumento ayon sa kinakailangan. Sa pamamagitan lamang ng mga pagkakaiba na ito ay maaaring naiiba ng tagatala sa pagitan ng dalawang labis na pag-andar.



Ang isa sa mga pangunahing bentahe ng labis na pag-load ng Function ay na pinapataas nito ang kakayahang mabasa ng programa dahil hindi namin kailangang gumamit ng iba't ibang mga pangalan para sa parehong pagkilos nang paulit-ulit.

Sa pamamagitan ng pagbabago ng Bilang ng mga Argumento

Sa ganitong paraan ng labis na pag-andar, tinutukoy namin ang dalawang pag-andar na may magkatulad na mga pangalan ngunit magkakaibang bilang ng mga parameter ng parehong uri. Halimbawa, sa nabanggit na programa, gumawa kami ng dalawang mga function na magdagdag () upang maibalik ang kabuuan ng dalawa at tatlong mga integer.

// first function kahulugan int add (int a, int b) {cout<< a+b } // second overloaded function definition int add(int a, int b, int c) { cout << a+b+c }

Dito ay nagdaragdag ng () pagpapaandar na sinasabing sobra ang karga, dahil mayroon itong dalawang kahulugan, isa na tumatanggap ng dalawang argumento at isa pa na tumatanggap ng tatlong argumento. Aling function ng pagdaragdag () ang tatawagin, nakasalalay sa bilang ng mga argumento.



int main () {add (10, 20) // add () na may 2 parameter ay tatawaging add (10, 20, 30) // sum () na may 3 parameter ay tatawaging}
# isama ang paggamit ng namespace std int add (int a, int b) {cout<< a+b <

Sa halimbawa sa itaas, labis kaming nagdagdag ng () pag-andar sa pamamagitan ng pagbabago ng bilang ng mga argumento. Una, tinutukoy namin ang isang function na magdagdag () na may dalawang mga parameter, pagkatapos ay overload namin ito sa pamamagitan ng muling pagtukoy sa pag-andar ng add () ngunit sa oras na ito na may tatlong mga parameter.

Sa pamamagitan ng pagkakaroon ng iba't ibang mga uri ng Argumento

Sa pamamaraang ito, tinutukoy namin ang dalawa o higit pang mga pagpapaandar na may parehong pangalan at parehong bilang ng mga parameter, ngunit ang uri ng data na ginamit para sa mga parameter na ito ay magkakaiba. Halimbawa sa program na ito, mayroon kaming tatlong function na add (), ang una ay nakakakuha ng dalawang argumento sa integer, ang pangalawa ay nakakakuha ng dalawang float na argumento at ang pangatlo ay nakakakuha ng dalawang dobleng argumento.

# isama ang paggamit ng namespace std int add (int x, int y) // unang kahulugan {cout<< x+y << endl return 0 } float add(float a, float b) { cout << a+b << endl return 0 } double add(double x, double y) { cout << x+y << endl return 0 } int main() { add(20, 40) add(23.45f, 34.5f) add(40.24, 20.433) }

Sa halimbawa sa itaas, tinutukoy namin ang pag-andar ng add () ng tatlong beses. Una na gumagamit ng mga integer bilang mga parameter, pangalawa gamit ang float bilang mga parameter at pangatlo gamit ang doble bilang isang parameter.
Sa gayon ay override namin ang add () function na dalawang beses.

Mga kalamangan ng pag-andar Overloading sa C ++

  • Gumagamit kami ng overloading ng pag-andar upang mai-save ang puwang ng memorya, pagkakapare-pareho, at kakayahang mabasa ng aming programa.

  • Gamit ang konsepto ng pag-andar ng labis na pag-andar ng paggamit, makakabuo tayo ng higit sa isang pagpapaandar na may parehong pangalan

    mga tutorial sa android studio para sa mga nagsisimula
  • Ang overloading ng pagpapaandar ay ipinapakita ang pag-uugali ng polymorphism na nagbibigay-daan sa amin upang makakuha ng iba't ibang pag-uugali, bagaman magkakaroon ng ilang link na gumagamit ng parehong pangalan ng pagpapaandar.

  • Ang sobrang pag-andar ng pagpapaandar ay nagpapabilis sa pagpapatupad ng programa.

  • Ginagamit ang pagpapaandar ng labis na pag-andar para sa muling paggamit ng code at i-save din ang memorya.

  • Tinutulungan nito ang application na mai-load ang pamamaraan ng klase batay sa uri ng parameter.

  • Madali ang pagpapanatili ng code.

Mga disadvantages ng pag-andar Overloading sa C ++

  • Ang mga pagpapaunlad na pagpapaandar na naiiba lamang sa pamamagitan ng uri ng pagbabalik ay hindi maaaring ma-overload ng proseso ng overloading ng pag-andar.
  • Ang mga pagdedeklara ng pag-andar ng miyembro na may parehong mga parameter o magkaparehong uri ng pangalan ay hindi maaaring mag-overload kung ang alinman sa mga ito ay idineklara bilang isang static na pagpapaandar ng miyembro.
  • class XYZ {static void func () void func () // error}

Pag-overload ng Pag-andar at Kalabuan

Kapag ang tagatala ay hindi makapagpasya kung aling pag-andar dapat itong ipatawag muna sa mga labis na pag-andar, ang sitwasyong ito ay kilala bilang kalabuan sa labis na pag-andar. Hindi pinapatakbo ng tagatala ang programa kung nagpapakita ito ng pagkakamali ng kalabuan. Mga Sanhi ng Function Overloading ambiguity:

  • I-type ang Conversion.
  • Pag-andar gamit ang mga default na argumento.
  • Pag-andar na may isang pumasa sa pamamagitan ng sanggunian

Uri ng Conversion:

# isama ang paggamit ng namespace std void function (float) void function (int) void function (float x) {std :: cout<< 'Value of x is : ' <

Ang halimbawa sa itaas ay nagtapon ng isang error - 'ang tawag sa sobrang karga na 'pagpapaandar (doble)' ay hindi siguradong'. Tatawagan ng pagpapaandar (3.4) ang unang pagpapaandar. Ang pagpapaandar (34) ay tumatawag sa pangalawang pagpapaandar ayon sa aming hula. Ngunit hindi ito ang nangyayari dahil sa C ++ lahat ng mga lumulutang-point na Constant ay itinuturing na doble hindi bilang isang float. Kung papalitan natin ang variable ng float sa isang dobleng variable, gagana nang maayos ang programa. Samakatuwid tinawag namin itong isang uri ng error sa conversion mula sa float hanggang sa doble.

Pag-andar sa Default na Mga Argumento:

factorial ng isang bilang java
# isama ang paggamit ng namespace std void function (int) void function (int, int) void function (int x) {std :: cout<< 'Value of x is : ' <

Ang halimbawa sa itaas ay nagbibigay ng isang error na sinasabing ang 'tawag ng sobrang karga na 'masaya (int)' ay hindi siguradong', ito ay dahil ang function (int y, int z = 12) ay maaaring tawagan sa dalawang paraan:

  1. Sa pamamagitan ng pagtawag sa pagpapaandar gamit ang isang argument (at awtomatiko itong kukuha ng halaga ng z = 12)
  2. Sa pamamagitan ng pagtawag sa pagpapaandar na may dalawang mga argumento.

Kapag tinawag namin ang pagpapaandar: pagpapaandar (12) buong pinupunan natin ang kundisyon ng parehong pag-andar (int) at pag-andar (int, int) sa gayon ang tagatala ay nakakakuha sa isang kalabuan ay nagpapakita ng isang error.

Pag-andar na may pumasa sa pamamagitan ng sanggunian

# isama ang paggamit ng namespace std void function (int) void function (int &) void function (int a) {std :: cout<< 'Value of a is : ' < 

Ang programa sa itaas ay nagbibigay ng isang error na nagsasabing 'hindi malinaw ang tawag ng labis na karga na 'masaya (int &)''. Tulad ng nakikita namin ang unang pag-andar ay tumatagal ng isang integer argument at ang pangalawang pagpapaandar ay tumatagal ng isang sanggunian na parameter bilang isang argument. Sa kasong ito, hindi maunawaan ng tagatala kung aling pag-andar ang kinakailangan ng gumagamit dahil walang syntactical na pagkakaiba sa pagitan ng kasiyahan (int) at kasiyahan (int &) sa gayon ay nag-shot ito ng isang error ng kalabuan.

Sa pamamagitan nito, natapos namin ang Function Overloading na ito sa C ++. Kung nais mong matuto nang higit pa, tingnan ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online. Ang kurso sa pagsasanay at sertipikasyon ng Java J2EE at SOA ng Edureka ay idinisenyo upang sanayin ka para sa parehong core at advanced na mga 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.