சி ++ பரம்பரை

C Inheritance



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

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







ஏன் பரம்பரை?

பரம்பரை மற்றொரு வர்க்கம் அல்லது அடிப்படை வகுப்பிலிருந்து ஒரு புதிய வகுப்பை அல்லது பெறப்பட்ட வகுப்பை உருவாக்க அனுமதிக்கிறது. பெறப்பட்ட வகுப்பு அல்லது குழந்தை வர்க்கம் பெற்றோர் வகுப்பு அல்லது அடிப்படை வகுப்பின் அனைத்து அம்சங்களையும் கொண்டிருக்கும். பரம்பரை உதவியுடன் குறியீட்டை நாம் மீண்டும் பயன்படுத்தலாம்.



பரம்பரை வகை

பல்வேறு வகையான பரம்பரை உள்ளன:



  1. எளிய/ஒற்றை பரம்பரை
  2. படிநிலை மரபுரிமை
  3. பல நிலை மரபுரிமை
  4. பல பரம்பரை

இந்த கட்டுரையில், நாம் எளிய/ஒற்றை பரம்பரை மட்டுமே கருத்தில் கொள்ளப் போகிறோம்.





எடுத்துக்காட்டு 1:

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

#சேர்க்கிறது

நேம்ஸ்பேஸ் எஸ்டிடியைப் பயன்படுத்துதல்;

வகுப்பு அடிப்படை_ வகுப்பு
{
பொது:
intநான்;
வெற்றிடம்காட்சி()
{
செலவு<< 'அடிப்படை வகுப்பின் காட்சி' <<நான்<<endl;
}

};

வகுப்பு பெறப்பட்டது_ வகுப்பு:பொது அடிப்படை_ வகுப்பு
{
பொது:
வெற்றிடம்நிகழ்ச்சி()
{
செலவு<< 'பெறப்பட்ட வகுப்பின் நிகழ்ச்சி' <<endl;
}
};

intமுக்கிய()
{
பெறப்பட்ட_ வகுப்பு dc;
டிசிநான் = 100;
டிசிகாட்சி();
டிசிநிகழ்ச்சி();

திரும்ப 0;
}



எடுத்துக்காட்டு 2:

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

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

#சேர்க்கிறது
நேம்ஸ்பேஸ் எஸ்டிடியைப் பயன்படுத்துதல்;

வகுப்பு அடிப்படை_ வகுப்பு
{
பொது:
அடிப்படை_ வகுப்பு()
{
செலவு<< 'அடிப்படை_ வகுப்பு - அளவுருக்கள் இல்லை' <<endl;
}
அடிப்படை_ வகுப்பு(intஎக்ஸ்)
{
செலவு<< 'அடிப்படை_ வகுப்பு - அளவுருக்கள்:' <<எக்ஸ்<<endl;
}
};

வகுப்பு பெறப்பட்டது_ வகுப்பு:பொது அடிப்படை_ வகுப்பு
{
பொது:
பெறப்பட்ட_ வகுப்பு()
{
செலவு<< 'பெறப்பட்ட_ வகுப்பு - அளவுருக்கள் இல்லை' <<endl;
}
பெறப்பட்ட_ வகுப்பு(intமற்றும்)
{
செலவு<< 'பெறப்பட்ட_ வகுப்பு - அளவுருக்கள்:' <<மற்றும்<<endl;
}
பெறப்பட்ட_ வகுப்பு(intஎக்ஸ்,intமற்றும்):அடிப்படை_ வகுப்பு(எக்ஸ்)
{
செலவு<< 'பரம் ஆஃப் டெரிவேட்_ கிளாஸ்:' <<மற்றும்<<endl;
}
};

intமுக்கிய()
{
பெறப்பட்ட_ வகுப்பு d(7,19);
}

உதாரணம் 3:

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

நீங்கள் பார்க்க முடியும் என, இரண்டு வகுப்புகள் வரையறுக்கப்பட்டுள்ளன: செவ்வகம்_குலம் மற்றும் கியூப்_வர்க்கம். செவ்வகம்_ வகுப்பு என்பது அடிப்படை வர்க்கத்திலிருந்து பெறப்பட்ட வர்க்கம், அதாவது கியூப்_ கிளாஸ் பெறப்பட்டது. ஆகையால், செவ்வக_குழியில் இருந்து கியூப்_களாஸ் வரையிலான அம்சங்களை நாம் பெறுகிறோம்.

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

பெறப்பட்ட வகுப்பின் ஒரு பொருளை நாங்கள் அறிவித்துள்ளோம், பின்னர் அடிப்படை வகுப்பிலிருந்து முறைகளை அழைக்கிறோம், அதாவது, setLength () மற்றும் setBreadth ().

#சேர்க்கிறது

நேம்ஸ்பேஸ் எஸ்டிடியைப் பயன்படுத்துதல்;

செவ்வகம்_ வகுப்பு
{
தனியார்:
intநீளம்;
intஅகலம்;
பொது:
செவ்வகம்_ வகுப்பு();
செவ்வகம்_ வகுப்பு(intதி,intb);
செவ்வகம்_ வகுப்பு(செவ்வகம்_ வகுப்பு&ஆர்);
intநீளம் கிடைக்கும்()
{
திரும்பநீளம்;
}
intgetBreadth()
{
திரும்பஅகலம்;
}
வெற்றிடம்செட் நீளம்(intதி);
வெற்றிடம்செட்பிரெட்(intb);
intபகுதி();
};

வகுப்பு க்யூப்_ வகுப்பு:பொது செவ்வகம்_ வகுப்பு
{
தனியார்:
intஉயரம்;
பொது:
கியூப்_ வகுப்பு(int)
{
உயரம்=;
}
intஉயரம் கிடைக்கும்()
{
திரும்பஉயரம்;
}
வெற்றிடம்உயரம்(int)
{
உயரம்=;
}
intதொகுதி()
{
திரும்பநீளம் கிடைக்கும்()*getBreadth()*உயரம்;
}
};


செவ்வகம்_ வகுப்பு::செவ்வகம்_ வகுப்பு()
{
நீளம்=1;
அகலம்=1;
}
செவ்வகம்_ வகுப்பு::செவ்வகம்_ வகுப்பு(intதி,intb)
{
நீளம்=தி;
அகலம்=b;
}
செவ்வகம்_ வகுப்பு::செவ்வகம்_ வகுப்பு(செவ்வகம்_ வகுப்பு&ஆர்)
{
நீளம்=ஆர்.நீளம்;
அகலம்=ஆர்.அகலம்;
}
வெற்றிடம்செவ்வகம்_ வகுப்பு::செட் நீளம்(intதி)
{
நீளம்=தி;
}
வெற்றிடம்செவ்வகம்_ வகுப்பு::செட்பிரெட்(intb)
{
அகலம்=b;
}
intசெவ்வகம்_ வகுப்பு::பகுதி()
{
திரும்பநீளம்*அகலம்;
}

intமுக்கிய()
{
க்யூப்_ கிளாஸ் சி(8);
cசெட் நீளம்(12);
cசெட்பிரெட்(9);
செலவு<<'தொகுதி'<<cதொகுதி()<<endl;
}

முடிவுரை:

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