Nilalaman

• 
  Tsart ng paghahambing:
• Kahulugan ng Overloading
• Pagpapatupad ng labis na karga sa C ++
• Kahulugan ng Overriding
• Pagpapatupad ng Overriding sa C ++
• Pagkakatulad
• Konklusyon

Sa 'labis na karga'Tinukoy namin ang mga sobrang pag-andar na may parehong pangalan ng pag-andar ngunit, iba't ibang numero at uri ng mga parameter. Sa 'overriding'Ang prototype ng overridden function ay pareho sa buong programa ngunit, ang pag-andar na ma-overridden ay nauna sa pamamagitan ng keyword na' virtual 'sa batayan ng batayan at muling tukuyin ng nagmula sa klase nang walang anumang keyword.

Ang Polymorphism ay isa sa mga mahahalagang tampok ng OOP. Nangangahulugan lamang ito ng 'paggamit ng isang pangalan para sa maraming mga form'. Maaaring maisagawa ang Polymorphism gamit ang 'function overloading', 'overloading' ng operator at 'virtual function'. Parehong, 'overloading' at 'overriding' ay nagpapahiwatig ng konsepto ng polymorphism. Dito, 'overloading' ang pag-compile ng oras polymorphism at 'overriding' ay run time polymorphism. Pag-aaral pa, kung pinag-uusapan natin ang pangunahing pagkakaiba sa 'labis na pagkarga' at 'overriding'.

Karagdagan, pinag-aaralan namin ang pagkakaiba sa pagitan ng labis na labis na labis at pag-override sa tulong ng isang tsart sa paghahambing.

1. Tsart ng paghahambing
2. Kahulugan
3. Pangunahing Pagkakaiba
4. Pagkakatulad
5. Konklusyon

Tsart ng paghahambing:

Batayan para sa Paghahambing	Sobrang karga	Sobra
Prototype	Ang Prototype ay naiiba bilang bilang o uri ng parameter ay maaaring magkakaiba.	Ang lahat ng aspeto ng prototype ay dapat na pareho.
Keyword	Walang inilapat na keyword sa panahon ng labis na karga.	Ang pag-andar na kung saan ay mapapansin ay nauna sa keyword virtual, sa klase ng base.
Ang kadahilanan ng pagkakaiba-iba	Ang bilang o uri ng parameter ay naiiba na tumutukoy sa bersyon ng pag-andar na tinatawag.	Aling mga pag-andar ng klase ang tinawag ng pointer, na tinutukoy ng, address kung aling mga klase ng klase ang itinalaga sa pointer.
Ang pattern ng pagtukoy	Ang pag-andar ay naisaayos na may parehong pangalan, ngunit iba't ibang numero at uri ng parameter.	Ang pag-andar ay tinukoy, nauna sa pamamagitan ng isang keyword virtual sa pangunahing klase at muling binibigyang kahulugan ng nagmula sa klase na may out keyword.
Oras ng nagawa	Magkumpuni ng oras.	Takbo ng oras.
Konstruktor / Virtual function	Ang mga konstruksyon ay maaaring ma-overload.	Ang virtual na pag-andar ay maaaring mapalitan.
Mapanganib	Hindi ma-overload ang Destructor.	Maaaring ma-overridden ang Destructor.
Nagbubuklod	Ang sobrang pag-load ay nakakamit ng maagang pagbubuklod.	Ang overriding ay tumutukoy sa huli na pagbubuklod.

Kahulugan ng Overloading

Ang compile-time polymorphism ay tinatawag na 'overloading.' Dahil ang sobrang pag-overload ay nabuo mula sa isang konsepto ng polymorphism, nagbibigay ito ng "isang karaniwang interface para sa maraming mga pamamaraan". Nangangahulugan ito, kung ang isang pag-andar ay na-overload, naglalaman ito ng parehong pangalan ng pag-andar habang ito ay nai-redefined.

Ang mga pag-andar ng labis na pag-andar ay naiiba tungkol sa, iba't ibang 'numero o uri ng mga (()), ginagawa nito ang isang overload na function na naiiba sa isa pa. Sa ganitong paraan, kinikilala ng tagatala kung aling labis na pag-andar ang tinawag. Karamihan sa mga karaniwang pag-andar ng labis na pag-andar ay 'konstruksyon'. Ang 'tagabuo ng kopya' ay isang uri ng "tagapagbigay ng labis na karga".

Pagpapatupad ng labis na karga sa C ++

labis na karga ng klase {int a, b; pampubliko: int load (int x) {// unang pag-load () function a = x; bumalik a; } int load (int x, int y) {// pangalawang pag-load () pag-andar ng isang = x; b = y; ibalik ang isang * b; }; int main () {labis na O1; O1.load (20); // unang pag-load () function na tawag sa O1.load (20,40); // pangalawang pag-load () function na tawag}

Narito ang pag-load ng function () ng overload ng klase ay na-overload. Ang dalawang sobrang pag-andar ng klase ay maaaring makilala sa isang paraan na ang unang pag-load () function ay tumatanggap lamang ng isang solong parameter ng integer, samantalang ang pangalawang pag-load () function ay tumatanggap ng dalawang parameter ng integer. Kapag tinawag ng object ng overload ng klase ang pag-load () function na may isang solong parameter, tatawagin muna ang pag-load (). Kapag nag-load ang mga tawag sa object () function na dumaan sa dalawang mga parameter, tatawagin ang pangalawang pag-load ().

Kahulugan ng Overriding

Ang Polymorphism na nakamit sa panahon ng run-time ay tinatawag na 'overriding.' Ito ay natutupad sa pamamagitan ng paggamit ng 'mana' at 'virtual function'. Ang pag-andar na ma-overridden ay nauna sa keyword na 'virtual' sa isang klase ng base at muling tukuyin sa isang nagmula na klase nang walang anumang keyword.

Ang isa sa mga pinakamahalagang bagay na dapat tandaan kung sakaling mapalampas ay ang prototype ng overridden function ay hindi dapat baguhin habang binibigyang-kahulugan ito ng klase. Kapag ang overridden function ay bibigyan ng isang tawag, tinutukoy ng C ++ kung aling bersyon ng pagpapaandar ang tinawag batay sa 'uri ng bagay na itinuro ng isang pointer' kung saan nagawa ang pagpapaandar ng pagpapaandar.

Pagpapatupad ng Overriding sa C ++

base ng klase {pampubliko: virtual void funct () {// virtual function ng base class cout << "Ito ay isang base classs functiont ()"; }; klase nagmula1: pampublikong batayan {pampubliko: walang saysay na gawat () {// virtual function ng base class na naisaayos din sa nagmula1 klase cout << "Ito ay isang nagmula1 klase na gawat ()"; }; klase nagmula2: pampublikong batayan {pampubliko: walang bisa functiont () {// virtual function ng base class na naisaayos din sa nagmula2 klase cout << "Ito ay isang nagmula2 na klase na gawa ()"; }; int main () {base * p, b; nagmula1 d1; nagmula2 d2; * p = & b; p-> funct (); // tumawag sa base klastt (). * p = & d1; p-> funct (); // tumawag sa nagmumula sa klase ng katulong (). * p = & d2; p-> funct (); // tumawag sa nagmula sa klase ng katusuhan (). bumalik 0; }

Dito, mayroong isang solong klase ng base na publiko na minana ng dalawang nagmula sa mga klase. Ang isang virtual na pag-andar ay tinukoy sa isang klase ng base na may isang keyword na 'virtual', at ito ay muling tukuyin ng parehong mga nagmula na klase na walang keyword. Sa pangunahing (), ang klase ng base ay lumilikha ng isang variable na pointer 'p' at isang object 'b'; 'Nagmula1 ′ klase ay lumilikha ng isang object d1 at nagmula sa klase ng klase2 ay lumilikha ng isang bagay d2'.

Ngayon, sa una ang address ng object ng bas ng klase 'ay itinalaga sa pointer ng base class na' p '. Nagbibigay ang 'p' ng isang tawag sa function na function (), kaya tinawag ang isang function ng klase ng base.Pagkatapos ang address ng nagmula sa klase ng object na 'd1' ay itinalaga sa pointer 'p', muli itong binibigyan ng tawag sa funct (); dito ang pagpapaandar ng function () ng nagmula1 na klase ay naisakatuparan. Sa wakas, ang pointer 'p' ay itinalaga sa object2 ng klase ng klase. Pagkatapos ay tinatawag ang function ng function na () na gumaganap ng function na function () ng nagmula sa klase.

Kung ang uri ng nagmula1 / nagmula2 ay hindi muling tukuyin ang (), kung gayon ang tawagt () ng base ng klase ay tatawagin, dahil ang virtual function ay 'hierarchical.'

1. Ang prototype ng isang function na kung saan ay labis na na-overload ay naiiba dahil sa uri at bilang ng mga parameter na ipinasa sa sobrang pag-andar. Sa kabilang banda, ang prototype ng overridden function ay hindi nagbabago dahil ang isang overridden function ay gumaganap ng iba't ibang pagkilos para sa iba't ibang klase na kabilang ito ngunit may parehong uri at bilang ng parameter.
2. Ang labis na labis na pangalan ng pag-andar ay hindi nangunguna sa anumang keyword samantalang, ang pangalan ng isang overridden function na nauna sa keyord na "Virtual" sa base ng klase lamang.
3. Alin ang labis na pag-andar na hinihimok ay nakasalalay sa uri o bilang ng parameter na ipinapasa sa pagpapaandar. Ang overridden na pag-andar ng kung saan ang klase ay naka-imbak ay nakasalalay, kung aling address ng object ng klase ang itinalaga sa pointer, na humihimok sa pagpapaandar.
4. Alin ang labis na pag-andar na dapat ma-invoke ay nalulutas sa pag-compile ng oras. Aling mga overridden function na maaaring ma-invoke ay nalutas sa panahon ng pag-runtime.
5. Ang mga konstruksyon ay maaaring ma-overload ngunit hindi ma-overridden.
6. Ang mga mapahamak ay hindi maaaring ma-overload, ngunit maaari itong mapalitan.
7. Ang sobrang pag-load ay nakakamit ng maagang pagbubuklod na kung saan ang sobrang pag-andar ay ma-invoke ay malulutas sa oras ng pag-compile. Nakakamit ang overriding late na nagbubuklod na kung saan ang overridden function ay ma-invoke ay nalulutas sa panahon ng runtime.

Pagkakatulad

1. Parehong inilalapat sa mga function ng miyembro ng isang klase.
2. Ang polymorphism ay ang pangunahing konsepto sa kanilang dalawa.
3. Ang pangalan ng pag-andar ay nananatiling pareho habang inilalapat namin ang labis na karga at overriding sa mga function.

Konklusyon

Ang overloading at overriding ay lilitaw na katulad, ngunit hindi ito ang nangyari. Ang mga pag-andar ay maaaring ma-overload ngunit, ang anumang klase ay hindi maaaring muling tukuyin ang labis na pag-andar sa hinaharap. Ang isang virtual na pag-andar ay hindi ma-overload; maaari lamang silang mapalitan.