சி ++ இல் செயல்பாடு ஓவர்லோடிங்: நீங்கள் தெரிந்து கொள்ள வேண்டியது எல்லாம்

இந்த கட்டுரை உங்களுக்கு சி ++ இல் செயல்பாட்டு ஓவர்லோடிங் பற்றிய விரிவான மற்றும் விரிவான அறிவை பல எடுத்துக்காட்டுகளுடன் புரிந்துகொள்ள உதவும்.

சி ++ என்பது மிகவும் நெகிழ்வான அந்த நிரலாக்க மொழிகளில் ஒன்றாகும், மேலும் இது பொருள் சார்ந்த நிரலாக்கத்தின் பல அம்சங்களையும் உள்ளடக்கியது. இந்த நிரலாக்க மொழியின் மற்றொரு அம்சம் ஓவர்லோடிங்.இந்த “சி ++ இல் செயல்பாட்டு ஓவர்லோடிங்” கட்டுரையில் பின்வரும் சுட்டிகள் அடங்கும்.

சி ++ ஓவர்லோடிங்

ஒரே வகுப்பைக் கொண்ட ஒரு வகுப்பின் இரண்டு அல்லது அதற்கு மேற்பட்ட உறுப்பினர்களை நாம் உருவாக்கும்போது, ​​ஆனால் எண்ணிக்கை அல்லது அளவுருக்களில் வேறுபட்டால், அது சி ++ ஓவர்லோடிங் என்று அழைக்கப்படுகிறது. சி ++ இல், நாம் ஓவர்லோட் செய்யலாம்:



  • முறைகள்,
  • கட்டமைப்பாளர்கள், மற்றும்
  • குறியீட்டு பண்புகள்

சி ++ இல் அதிக சுமை வகைகள்

types-of-overloading-in-c++

சி ++ இல் செயல்பாடு ஓவர்லோடிங் என்றால் என்ன?

சி ++ இல் செயல்பாடு ஓவர்லோடிங் என்பது ஒரு வகுப்பின் இரண்டு அல்லது அதற்கு மேற்பட்ட உறுப்பினர் செயல்பாடுகளை ஒரே பெயரில் கொண்டதாக வரையறுக்கப்படுகிறது, ஆனால் அளவுருக்களில் வேறுபட்டது. செயல்பாடு ஓவர்லோடிங்கில், தேவைக்கேற்ப வெவ்வேறு வகையான வாதங்கள் அல்லது வேறுபட்ட வாதங்களைப் பயன்படுத்துவதன் மூலம் செயல்பாட்டை மறுவரையறை செய்யலாம். இந்த வேறுபாடுகளின் மூலம்தான் இரு சுமை செயல்பாடுகளுக்கு இடையில் கம்பைலர் வேறுபடுத்த முடியும்.

செயல்பாட்டு ஓவர்லோடிங்கின் முக்கிய நன்மைகளில் ஒன்று, இது நிரலின் வாசிப்புத் திறனை அதிகரிக்கிறது, ஏனென்றால் ஒரே செயலுக்கு வெவ்வேறு பெயர்களை மீண்டும் மீண்டும் பயன்படுத்த வேண்டிய அவசியமில்லை.

வாதங்களின் எண்ணிக்கையை மாற்றுவதன் மூலம்

செயல்பாட்டு ஓவர்லோடிங்கின் இந்த வழியில், ஒரே பெயர்களைக் கொண்ட இரண்டு செயல்பாடுகளை வரையறுக்கிறோம், ஆனால் ஒரே வகையின் வேறுபட்ட அளவுருக்கள். எடுத்துக்காட்டாக, கீழே குறிப்பிடப்பட்டுள்ள நிரலில், இரண்டு மற்றும் மூன்று முழு எண்களின் தொகையைத் திருப்ப இரண்டு சேர்க்க () செயல்பாடுகளைச் செய்துள்ளோம்.

// முதல் செயல்பாட்டு வரையறை 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 }

இங்கே சேர் () செயல்பாடு ஓவர்லோட் என்று கூறப்படுகிறது, ஏனெனில் இது இரண்டு வரையறைகளைக் கொண்டுள்ளது, ஒன்று இரண்டு வாதங்களை ஏற்றுக்கொள்கிறது, மற்றொன்று மூன்று வாதங்களை ஏற்றுக்கொள்கிறது. எந்த சேர் () செயல்பாடு அழைக்கப்படும், இது வாதங்களின் எண்ணிக்கையைப் பொறுத்தது.

int main () {சேர் (10, 20) // 2 அளவுருவுடன் சேர் () சேர் (10, 20, 30) // தொகை () 3 அளவுருவுடன் அழைக்கப்படும்}
# பெயர்வெளியைப் பயன்படுத்தி சேர்க்கவும் std int add (int a, int b) out cout<< a+b <

மேலே உள்ள எடுத்துக்காட்டில், அதன் வாதங்களின் எண்ணிக்கையை மாற்றுவதன் மூலம் சேர் () செயல்பாட்டை ஓவர்லோட் செய்கிறோம். முதலில், இரண்டு அளவுருக்கள் கொண்ட ஒரு சேர் () செயல்பாட்டை வரையறுக்கிறோம், பின்னர் மீண்டும் சேர் () செயல்பாட்டை வரையறுப்பதன் மூலம் அதை ஓவர்லோட் செய்கிறோம், ஆனால் இந்த முறை மூன்று அளவுருக்களுடன்.

பல்வேறு வகையான வாதங்களைக் கொண்டிருப்பதன் மூலம்

இந்த முறையில், ஒரே பெயர் மற்றும் ஒரே எண்ணிக்கையிலான அளவுருக்கள் கொண்ட இரண்டு அல்லது அதற்கு மேற்பட்ட செயல்பாடுகளை நாங்கள் வரையறுக்கிறோம், ஆனால் இந்த அளவுருக்களுக்கு பயன்படுத்தப்படும் தரவு வகை வேறுபட்டது. எடுத்துக்காட்டாக, இந்த நிரலில், எங்களுக்கு மூன்று சேர் () செயல்பாடு உள்ளது, முதல் ஒன்று இரண்டு முழு எண் வாதங்களைப் பெறுகிறது, இரண்டாவது ஒன்று இரண்டு மிதவை வாதங்களைப் பெறுகிறது, மூன்றாவது ஒன்று இரண்டு இரட்டை வாதங்களைப் பெறுகிறது.

# பெயர்வெளியைப் பயன்படுத்தி சேர்க்கவும் std int add (int x, int y) // முதல் வரையறை {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) }

முதுகலை சான்றிதழ் Vs முதுநிலை

மேலே உள்ள எடுத்துக்காட்டில், சேர் () செயல்பாட்டை மூன்று முறை வரையறுக்கிறோம். முதலில் முழு எண்களை அளவுருக்களாகவும், இரண்டாவது மிதவை அளவுருக்களாகவும், மூன்றாவது அளவுருவைப் போலவும் பயன்படுத்துகின்றன.
இவ்வாறு நாம் சேர் () செயல்பாட்டை இரண்டு முறை மேலெழுதும்.

சி ++ இல் ஓவர்லோடிங் செயல்பாட்டின் நன்மைகள்

  • எங்கள் நிரலின் நினைவக இடம், நிலைத்தன்மை மற்றும் வாசிப்புத்திறனைச் சேமிக்க செயல்பாட்டு ஓவர்லோடிங்கைப் பயன்படுத்துகிறோம்.

  • பயன்பாட்டு செயல்பாடு ஓவர்லோடிங் கருத்துடன், ஒரே பெயரில் ஒன்றுக்கு மேற்பட்ட செயல்பாடுகளை உருவாக்கலாம்

  • செயல்பாட்டு ஓவர்லோடிங் என்பது பாலிமார்பிஸத்தின் நடத்தையைக் காட்டுகிறது, இது வெவ்வேறு நடத்தைகளைப் பெற அனுமதிக்கிறது, இருப்பினும் செயல்பாட்டின் அதே பெயரைப் பயன்படுத்தி சில இணைப்பு இருக்கும்.

  • செயல்பாட்டு ஓவர்லோடிங் நிரலை செயல்படுத்துவதை வேகப்படுத்துகிறது.

  • குறியீடு மறுபயன்பாட்டிற்கும் நினைவகத்தை சேமிக்கவும் செயல்பாட்டு ஓவர்லோடிங் பயன்படுத்தப்படுகிறது.

  • அளவுருவின் வகையின் அடிப்படையில் வகுப்பு முறையை ஏற்ற பயன்பாட்டை இது உதவுகிறது.

  • குறியீடு பராமரிப்பு எளிதானது.

சி ++ இல் ஓவர்லோடிங் செயல்பாட்டின் குறைபாடுகள்

  • செயல்பாட்டு வகை ஏற்றுதல் செயல்முறையுடன் அதன் வருவாய் வகையால் மட்டுமே வேறுபடும் செயல்பாட்டு அறிவிப்புகளை ஓவர்லோட் செய்ய முடியாது.
  • உறுப்பு உறுப்பினர் செயல்பாடாக அறிவிக்கப்பட்டால், அதே அளவுருக்கள் அல்லது அதே பெயர் வகைகளைக் கொண்ட உறுப்பினர் செயல்பாடு அறிவிப்புகளை ஓவர்லோட் செய்ய முடியாது.
  • வகுப்பு XYZ {நிலையான வெற்றிட ஃபங்க் () வெற்றிட ஃபங்க் () // பிழை}

செயல்பாடு ஓவர்லோடிங் மற்றும் தெளிவின்மை

அதிக சுமை கொண்ட செயல்பாடுகளில் எந்த செயல்பாட்டை முதலில் செயல்படுத்த வேண்டும் என்பதை கம்பைலரால் தீர்மானிக்க முடியாதபோது, ​​இந்த நிலைமை செயல்பாடு ஓவர்லோடிங் தெளிவின்மை என அழைக்கப்படுகிறது. தெளிவற்ற பிழையைக் காட்டினால் கம்பைலர் நிரலை இயக்காது. செயல்பாட்டின் காரணங்கள் ஓவர்லோடிங் தெளிவின்மை:

  • மாற்றத்தை தட்டச்சு செய்க.
  • இயல்புநிலை வாதங்களுடன் செயல்பாடு.
  • குறிப்பு மூலம் பாஸுடன் செயல்பாடு

வகை மாற்றம்:

# பெயர்வெளியைப் பயன்படுத்தி சேர்க்கவும் std void function (float) void function (int) void function (float x) {std :: cout<< 'Value of x is : ' <

மேலே உள்ள எடுத்துக்காட்டு ஒரு பிழையை வீசுகிறது - “அதிக சுமை கொண்ட‘ செயல்பாடு (இரட்டை) ’அழைப்பு தெளிவற்றது. செயல்பாடு (3.4) முதல் செயல்பாட்டை அழைக்கும். செயல்பாடு (34) எங்கள் கணிப்புக்கு ஏற்ப இரண்டாவது செயல்பாட்டை அழைக்கிறது. ஆனால் இது நடப்பதில்லை, ஏனெனில் சி ++ இல் அனைத்து மிதக்கும்-புள்ளி மாறிலிகளும் மிதவை போல இரட்டிப்பாக கருதப்படுகின்றன. மிதவை மாறியை இரட்டை மாறிக்கு மாற்றினால், நிரல் நன்றாக வேலை செய்யும். எனவே இதை மிதப்பிலிருந்து இரட்டிப்பாக மாற்றுவதற்கான பிழை என்று அழைக்கிறோம்.

இயல்புநிலை வாதங்களுடன் செயல்பாடு:

# பெயர்வெளியைப் பயன்படுத்துதல் std வெற்றிட செயல்பாடு (int) வெற்றிட செயல்பாடு (int, int) வெற்றிட செயல்பாடு (int x) {std :: cout<< 'Value of x is : ' <

மேலேயுள்ள எடுத்துக்காட்டு “அதிக சுமை கொண்ட‘ வேடிக்கை (எண்ணாக) அழைப்பது தெளிவற்றது ”என்று ஒரு பிழையைத் தருகிறது, ஏனென்றால் செயல்பாடு (int y, int z = 12) இரண்டு வழிகளில் அழைக்கப்படலாம்:

  1. ஒரு வாதத்துடன் செயல்பாட்டை அழைப்பதன் மூலம் (அது தானாகவே z = 12 இன் மதிப்பை எடுக்கும்)
  2. இரண்டு வாதங்களுடன் செயல்பாட்டை அழைப்பதன் மூலம்.

நாம் செயல்பாட்டை அழைக்கும்போது: செயல்பாடு (12) செயல்பாடு (முழு எண்ணாக) மற்றும் செயல்பாடு (எண்ணாக, எண்ணாக) இரண்டின் நிலையை முழுமையாக நிரப்புகிறோம், இதனால் தொகுப்பி ஒரு தெளிவின்மைக்குள் ஒரு பிழையைக் காட்டுகிறது.

குறிப்பு மூலம் பாஸுடன் செயல்பாடு

# பெயர்வெளியைப் பயன்படுத்துதல் std void function (int) void function (int &) void function (int a) {std :: cout<< 'Value of a is : ' < 

மேலே உள்ள நிரல் “அதிக சுமை கொண்ட‘ வேடிக்கையான (எண்ணாக &) ’அழைப்பு தெளிவற்றது” என்று ஒரு பிழையை அளிக்கிறது. நாம் பார்க்கும்போது முதல் செயல்பாடு ஒரு முழு எண் வாதத்தையும் இரண்டாவது செயல்பாடு ஒரு குறிப்பு அளவுருவை ஒரு வாதமாக எடுத்துக்கொள்கிறது. இந்த விஷயத்தில், வேடிக்கை (எண்ணாக) மற்றும் வேடிக்கையானது (எண்ணாக &) இடையே எந்தவிதமான வேறுபாடும் இல்லாததால் பயனருக்கு எந்த செயல்பாடு தேவை என்பதை கம்பைலரால் புரிந்து கொள்ள முடியவில்லை, இதனால் இது தெளிவற்ற பிழையைக் காட்டுகிறது.

இதன் மூலம், சி ++ இல் இந்த செயல்பாட்டு ஓவர்லோடிங்கின் முடிவுக்கு வருகிறோம். நீங்கள் மேலும் அறிய விரும்பினால், பாருங்கள் வழங்கியவர் நம்பகமான ஆன்லைன் கற்றல் நிறுவனம். எடுரேகாவின் ஜாவா ஜே 2 இஇ மற்றும் எஸ்ஓஏ பயிற்சி மற்றும் சான்றிதழ் பாடநெறி, முக்கிய மற்றும் மேம்பட்ட ஜாவா கருத்தாக்கங்களுக்கும், ஹைபர்னேட் & ஸ்பிரிங் போன்ற பல்வேறு ஜாவா கட்டமைப்புகளுக்கும் பயிற்சி அளிக்க வடிவமைக்கப்பட்டுள்ளது.

எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? தயவுசெய்து இந்த வலைப்பதிவின் கருத்துகள் பிரிவில் குறிப்பிடவும், விரைவில் நாங்கள் உங்களைத் தொடர்புகொள்வோம்.