OOP, கன்ஸ்ட்ரக்டர்கள் மற்றும் டிஸ்ட்ரக்டர்கள் பற்றி பேசிய பிறகு, இப்போது மெய்நிகர் அழிப்பான்களைப் பற்றி பேசலாம். மெய்நிகர் அழிப்பான்கள், பெயர் குறிப்பிடுவது போல, பொருளை அழிக்கின்றன. எங்களிடம் ஒரு அடிப்படை வகுப்பு மற்றும் அடிப்படை வகுப்பிலிருந்து பெறப்பட்ட ஒரு பெறப்பட்ட வகுப்பு உள்ளது. இரண்டு வகுப்புகளும் அவற்றின் கட்டமைப்பாளர்களையும் அழிப்பாளர்களையும் கொண்டிருக்கின்றன. விர்ச்சுவல் டிஸ்ட்ரக்டர், 'மெய்நிகர்' முக்கிய சொல்லுடன் அடிப்படை வகுப்பு பாயிண்டரைப் பயன்படுத்தி பெறப்பட்ட வகுப்பின் பொருள்களை நீக்கும் போது, பெறப்பட்ட கிளாஸ் ஆப்ஜெக்ட் மூலம் ஒதுக்கப்படும் நினைவூட்டலை விடுவிக்கிறது.
நாம் ஏன் விர்ச்சுவல் டிஸ்ட்ரக்டரைப் பயன்படுத்துகிறோம்?
கிளாஸ் மெம்பர் செயல்பாடுகளைச் செயல்படுத்தும் போது அல்லது மெயின்() முறையின் செயலாக்கம் முடிவடையும் போது, பொருள் உருவாக்கத்தின் போது ஒதுக்கப்பட்ட நினைவகத்தை விடுவிக்க அழிப்பான் தானாகவே அழைக்கப்படும். இப்போது, நாம் ஏன் மெய்நிகர் டிஸ்ட்ரக்டரைப் பயன்படுத்துகிறோம்? பெறப்பட்ட வகுப்பைச் சுட்டிக்காட்டும் அடிப்படை வகுப்பு நீக்கப்படும்போது, சுட்டி (*) இங்கே பயன்படுத்தப்படுகிறது. அடிப்படை வகுப்பு அழிப்பான் இந்த செயல்பாட்டின் போது மட்டுமே அழைக்கப்படுகிறது. பெறப்பட்ட கிளாஸ் டிஸ்ட்ரக்டர் என்று அழைக்கப்படவில்லை, இது சிக்கல்களுக்கு வழிவகுக்கிறது. அவற்றில் ஒன்று நினைவக கசிவு பிரச்சினை. இந்தச் சிக்கலைத் தவிர்க்கவும், எங்கள் குறியீட்டைப் பாதுகாக்கவும், அடிப்படை வகுப்பு அழிப்பான்களை நீக்குவதன் மூலம், பொருட்களை உருவாக்கும் போது ஒதுக்கப்பட்ட நினைவக இடத்தை விடுவிக்க, பொருட்களை கிட்டத்தட்ட அழிக்கிறோம்.
விர்ச்சுவல் டிஸ்ட்ரக்டர் இல்லாத சி++ அடிப்படை எடுத்துக்காட்டு
சுட்டியை நீக்கும் எளிய நிரலுடன் மெய்நிகர் அழிப்பான் இல்லாமல் நிரல் எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்.
குறியீடு:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு பெற்றோர்_வகுப்பு0
{
பொது :
பெற்றோர்_வகுப்பு0 ( )
{ கூட் << 'பெற்றோர் வகுப்பு கட்டமைப்பாளர்' << endl ; }
~பெற்றோர்_வகுப்பு0 ( )
{ கூட் << 'பெற்றோர் வகுப்பு அழிப்பான்' << endl ; }
} ;
வகுப்பு குழந்தை_1 : பொது பெற்றோர்_வகுப்பு0
{
பொது :
குழந்தை_1 ( )
{ கூட் << 'குழந்தை வகுப்பு கட்டமைப்பாளர்' << endl ; }
~குழந்தை_1 ( )
{ கூட் << 'குழந்தை வகுப்பு அழிப்பான்' << endl ; }
} ;
முழு எண்ணாக முக்கிய ( )
{
பெற்றோர்_வகுப்பு0 * சுட்டி = புதிய குழந்தை_1 ( ) ;
சுட்டியை நீக்கு ;
திரும்ப 0 ;
}
விர்ச்சுவல் டிஸ்ட்ரக்டர் இல்லாமல் குறியீடு எவ்வாறு இயங்குகிறது என்பதை இந்தக் குறியீடு விளக்குகிறது. முதலில், பெற்றோர் வகுப்பாக இருக்கும் “Parent_Class0” என்ற வகுப்பை உருவாக்கவும். இந்த வகுப்பிற்குள், ஒரு கன்ஸ்ட்ரக்டர் மற்றும் டிஸ்ட்ரக்டரை உருவாக்கவும். நாம் அறிந்தபடி, கன்ஸ்ட்ரக்டர் மற்றும் டிஸ்ட்ரக்டர் வர்க்கம் என பெயரிடப்பட்டுள்ளது. கன்ஸ்ட்ரக்டரைப் போலவே டிஸ்ட்ரக்டரும் குறிப்பிடப்படுகிறது, ஆனால் அது ஒரு சின்னத்தைக் கொண்டுள்ளது (~) அதை கட்டமைப்பாளரிடமிருந்து வேறுபடுத்துகிறது. கன்ஸ்ட்ரக்டர் மற்றும் டிஸ்ட்ரக்டரின் உள்ளே, “cout<<” ஐப் பயன்படுத்தி ஒரு செய்தியை அச்சிடவும். இப்போது, 'Child_1' என்ற மற்றொரு வகுப்பை உருவாக்கவும். இந்த வகுப்பு 'Parent_Class0' என்ற பெற்றோர் வகுப்பிலிருந்து பெறப்பட்டது. பெறப்பட்ட வகுப்பில் அதன் கன்ஸ்ட்ரக்டர் மற்றும் டிஸ்ட்ரக்டர் உள்ளது, அதில் வெளியீட்டுத் திரையில் அச்சிடுவதற்கான செய்தி உள்ளது.
பிரதான() முறையில், 'Parent_Class0' இன் நிகழ்வை உருவாக்கி, அதற்கு ஒரு பெறப்பட்ட வகுப்பை ஒதுக்குவோம். இந்த விஷயத்தில் நினைவில் கொள்ள வேண்டிய முக்கியமான விஷயம் என்னவென்றால், பெற்றோர் வகுப்பை மீட்டெடுக்க ஒரு சுட்டியைப் பயன்படுத்துகிறோம். அது பெற்றோர் வகுப்பிற்குள் செல்லும்போது, அது பெற்றோர் வகுப்பு கட்டமைப்பாளரை இயக்குகிறது. பின்னர், அது குழந்தை வகுப்பிற்குச் சென்று அதன் கட்டமைப்பாளரை செயல்படுத்துகிறது. குழந்தை வகுப்பை அழிப்பவரை இயக்குவதற்கு முன், அது பெற்றோர் வகுப்பின் அழிப்பாளரைச் செயல்படுத்த வேண்டும். கம்பைலர், பெற்றோர் வகுப்பை அழிப்பவரை இயக்கி, குழந்தை வகுப்பை அழிப்பவரை இயக்காமல் வகுப்பை முடிக்கிறார். அதுதான் பிரச்சனை; இது குழந்தையின் வகுப்பின் நினைவகத்தை விடுவிக்காது. இது ஒரு பெற்றோர் வகுப்பின் கட்டமைப்பாளர், குழந்தை வகுப்பின் கட்டமைப்பாளர் மற்றும் ஒரு பெற்றோர் வகுப்பை அழிப்பவர் ஆகியவற்றைக் குறிக்கிறது. ஒரு குழந்தை வகுப்பை அழிப்பவர் தூக்கிலிடப்படவில்லை என்பதை இது காட்டுகிறது. இந்தச் செயல்பாட்டிற்குப் பிறகு, முக்கிய() செயல்பாட்டில் உள்ள சுட்டியை நீக்குவோம்.
வெளியீடு:
விர்ச்சுவல் டிஸ்ட்ரக்டருடன் சி++ எடுத்துக்காட்டு
விர்ச்சுவல் டிஸ்ட்ரக்டருடன் மற்றும் இல்லாமலேயே அது எவ்வாறு செயல்படுகிறது என்பதை வேறுபடுத்த எளிய குறியீட்டைக் கொண்டு விர்ச்சுவல் டிஸ்ட்ரக்டரைப் பற்றி விவாதிப்போம்.
குறியீடு:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு பெற்றோர்_வகுப்பு0
{
பொது :
பெற்றோர்_வகுப்பு0 ( )
{ கூட் << 'பெற்றோர் வகுப்பு கட்டமைப்பாளர்' << endl ; }
மெய்நிகர் ~Parent_Class0 ( )
{ கூட் << 'பெற்றோர் வகுப்பு அழிப்பான்' << endl ; }
} ;
வகுப்பு குழந்தை_1 : பொது பெற்றோர்_வகுப்பு0
{
பொது :
குழந்தை_1 ( )
{ கூட் << 'குழந்தை வகுப்பு கட்டமைப்பாளர்' << endl ; }
மெய்நிகர் ~குழந்தை_1 ( )
{ கூட் << 'குழந்தை வகுப்பு அழிப்பான்' << endl ; }
} ;
முழு எண்ணாக முக்கிய ( )
{
பெற்றோர்_வகுப்பு0 * சுட்டி = புதிய குழந்தை_1 ( ) ;
சுட்டியை நீக்கு ;
திரும்ப 0 ;
}
முதல் நிரல் மெய்நிகர் அழிப்பான் இல்லாமல் நாம் எதிர்கொள்ளும் சிக்கலை விளக்கியது. இப்போது, இந்த குறியீடு ஒரு மெய்நிகர் அழிப்பான் மூலம் அந்த சிக்கலை தீர்க்கும். முதலில், முதல் குறியீட்டை நகலெடுத்து, இந்தத் திட்டத்தில் இரண்டு இடங்களில் ஒரு முக்கிய சொல்லைச் சேர்க்கவும். அந்த வார்த்தை 'மெய்நிகர்'. 'Parent_Class0' என்ற பெற்றோர் வகுப்பின் அழிப்பாளருடன் இந்த வார்த்தையைச் செருகவும். இதேபோல், பெற்றோர் வகுப்பிலிருந்து பெறப்பட்ட “Child_1” என்ற குழந்தை வகுப்பின் அழிப்பாளருடன் இதைக் குறிப்பிடவும். இந்த 'மெய்நிகர்' முக்கிய சொல் ஒரு சிறிய மாற்றத்தை ஏற்படுத்துகிறது, மேலும் இது 'Child_1' குழந்தை வகுப்பை அழிப்பவரை முதலில் செயல்படுத்துகிறது. பின்னர், அது 'Parent_Class0' என்ற பெற்றோர் வகுப்பின் அழிப்பாளரைச் செயல்படுத்துகிறது. விர்ச்சுவல் டிஸ்ட்ரக்டர் இல்லாமல் செயல்படுவதைப் போலவே மீதமுள்ள நிரலும் செயல்படுகிறது. இந்த சிறிய குறியீட்டைச் சேர்ப்பதன் மூலம், நமது நினைவகத்தை கசிவிலிருந்து காப்பாற்ற முடியும். இப்போது, இது கன்சோலில் நான்கு செய்திகளைக் காட்டுகிறது. முதலில், ஒரு பெற்றோர் வகுப்பின் கட்டமைப்பாளர், பின்னர் ஒரு குழந்தை வகுப்பின் கட்டமைப்பாளர், ஒரு குழந்தை வகுப்பை அழிப்பவர் மற்றும் ஒரு பெற்றோர் வகுப்பை அழிப்பவர். இறுதியில், முக்கிய() முறையில் உள்ள சுட்டியை நீக்குவோம்.
வெளியீடு:
C++ Pure Virtual Destructor இன் எடுத்துக்காட்டு
இந்த குறியீட்டில், தூய மெய்நிகர் அழிப்பான், அது எவ்வாறு செயல்படுகிறது மற்றும் மெய்நிகர் அழிப்பாளரிடமிருந்து எவ்வாறு வேறுபடுகிறது என்பதைப் பற்றி பேசுவோம்.
குறியீடு:
#வகுப்பு பெற்றோர்_0 {
பொது :
மெய்நிகர் ~Parent_0 ( ) = 0 ;
} ;
பெற்றோர்_0 :: ~பெற்றோர்_0 ( )
{
வகுப்பு :: கூட் << 'ஹலோ நான் பியூர் டிஸ்ட்ரக்டர். நீ என்னை அழைத்தாய்!' ;
}
வகுப்பு குழந்தை_0 : பொது பெற்றோர்_0 {
பொது :
~குழந்தை_0 ( ) { வகுப்பு :: கூட் << 'பெறப்பட்ட அழிப்பான் இங்கே உள்ளது \n ' ; }
} ;
முழு எண்ணாக முக்கிய ( )
{
பெற்றோர்_0 * ptr_0 = புதிய குழந்தை_0 ( ) ;
ptr_0 ஐ நீக்கு ;
திரும்ப 0 ;
}
'Parent_0' என்ற பெற்றோர் வகுப்பு குறியீட்டின் முதல் படியில் உருவாக்கப்பட்டது. அதன் உள்ளே, மெய்நிகர் பெற்றோர் அழிப்பான் உருவாக்கி அதை 0 உடன் ஒதுக்கவும். இது மெய்நிகர் அழிப்பாளரை தூய மெய்நிகர் அழிப்பாளராக அமைக்கிறது, அதாவது பெற்றோர் வகுப்பு இப்போது சுருக்கமாக உள்ளது, மேலும் இந்த வகுப்பின் நிகழ்வுகளை உருவாக்க முடியாது. பெற்றோர் வகுப்பிற்கு வெளியே “Parent_0”, அழிப்பவர்களை வரையறுக்கவும் மற்றும் std::cout. std::cout ஐப் பயன்படுத்தி தேவையான உரை காட்டப்படும். பின்னர், பெற்றோர் வகுப்பிலிருந்து “Child_0” வகுப்பைப் பெற்று அதன் அழிப்பாளரைக் குறிப்பிடவும். டிஸ்ட்ரக்டரின் உள்ளே, ஒரு செய்தியை அச்சிடவும். பிரதான() செயல்பாட்டில், பெற்றோர் வகுப்பின் சுட்டியை உருவாக்கி, அதற்கு குழந்தை வகுப்பை ஒதுக்கவும்.
கம்பைலர் 'Parent_0' என்ற பெற்றோர் வகுப்பிற்குச் செல்கிறது. சுட்டிக்காட்டி உருவாக்கப்படும் போது, அதன் கட்டமைப்பாளர் தானாகவே அழைக்கப்படும். பின்னர், கம்பைலர் அதன் கட்டமைப்பாளரை அழைக்க குழந்தை வகுப்பிற்குள் செல்கிறார். கன்ஸ்ட்ரக்டரை வெற்றிகரமாகச் செயல்படுத்திய பிறகு, அது குழந்தை வகுப்பான “Child_0”ஐ அழிப்பவரை இயக்குகிறது. பின்னர், அது ஒரு பெற்றோர் வகுப்பை அழிப்பவரை இயக்குகிறது. இந்த வழியில், நாம் ஒரு தூய விர்ச்சுவல் டிஸ்ட்ரக்டரை உருவாக்க முடியும். இதைப் பயன்படுத்த ஊக்குவிக்கப்படவில்லை, ஏனெனில் இந்த முறையைப் பயன்படுத்துவதன் மூலம், பெற்றோர் வர்க்கம் சுருக்கமாகிறது, இது பயனற்றதாக ஆக்குகிறது. பெரும்பாலும் பயன்படுத்தப்படும் முறை மெய்நிகர் அழிப்பான் மற்றும் இது ஒரு நல்ல நடைமுறையாகும்.
வெளியீடு:
முடிவுரை
விர்ச்சுவல் டிஸ்ட்ரக்டரைப் பற்றி OOP என்ற கருத்தாக்கத்திலிருந்து தொடங்கி, கன்ஸ்ட்ரக்டர்கள் மற்றும் டிஸ்ட்ரக்டர்களை நோக்கி நகர்வதைக் கற்றுக்கொண்டோம். இவை அனைத்தையும் விளக்கிய பிறகு, குறியீட்டு எடுத்துக்காட்டுகள் மற்றும் தூய மெய்நிகர் அழிப்பாளருடன் மெய்நிகர் அழிப்பான் பற்றி விரிவாக விவாதித்தோம். விர்ச்சுவல் டிஸ்ட்ரக்டரை விளக்குவதற்கு முன், கட்டமைப்பாளர்கள், அழிப்பவர்கள் மற்றும் பரம்பரை பற்றி நாம் தெரிந்து கொள்ள வேண்டும். பரம்பரையில், பெற்றோர் வகுப்பிலிருந்து வகுப்புகளைப் பெறுகிறோம். குழந்தை வகுப்புகள் ஒன்றுக்கு மேற்பட்டதாக இருக்கலாம் ஆனால் பெற்றோர் வகுப்பு ஒன்று மட்டுமே. நினைவக கசிவிலிருந்து காப்பாற்ற, மெய்நிகர் அழிப்பான்கள் மற்றும் தூய மெய்நிகர் அழிப்பான்கள் மரபுரிமையில் பயன்படுத்தப்படுகின்றன. அடிப்படை உதாரணம் முதல் மேம்பட்ட உதாரணம் வரை, பெறப்பட்ட வகுப்பின் நினைவகத்தைப் பயன்படுத்தத் தொடங்குவதற்கும் கிட்டத்தட்ட அழிக்கப்படுவதற்கும் நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தையும் நாங்கள் உள்ளடக்கியுள்ளோம்.