C++ இல் ஆபரேட்டர் தேர்வு மற்றும் நினைவக மேலாண்மை
விருப்ப செயலாக்கங்கள் மற்றும் C++ இல் உள்ள ஆபரேட்டர்கள் மிகப்பெரிய நினைவக மேலாண்மை சுதந்திரத்தை வழங்குகிறார்கள். இந்த ஆபரேட்டர்கள் டெவலப்பர்களுக்கு தங்கள் வகுப்புகளுக்குள் நினைவகத்தின் ஒதுக்கீடு மற்றும் விநியோகத்தின் மீது கட்டுப்பாட்டை வழங்குகிறார்கள். துணைப்பிரிவு குழப்பத்திற்கு வழிவகுக்கும், குறிப்பாக தேர்ந்தெடுக்கும் போது நீக்கவும் பொருள் அழிவுக்கான ஆபரேட்டர்.
C++ இல் ஆபரேட்டர் ஓவர்லோடிங் வழக்கில், சரியான தேர்வு ஆபரேட்டர் நேரடியாகத் தோன்றுகிறார், ஏனெனில் உண்மையான வகுப்பு ஒதுக்கீட்டில் அறியப்படுகிறது. இருப்பினும், பொருத்தமான நீக்க ஆபரேட்டரைத் தேர்ந்தெடுப்பது மிகவும் நுட்பமாக இருக்கும், குறிப்பாக ஒரு அடிப்படை வகுப்பு சுட்டிக்காட்டி பெறப்பட்ட வகுப்பின் நிகழ்வை இணைக்கும் போது.
ஒரு அடிப்படை வகுப்பு சுட்டிக்காட்டி ஒரு பெறப்பட்ட வகுப்பு பொருளை நீக்கும் போது, C++ பயன்படுத்துமா அடிப்படை அல்லது பெறப்பட்ட வகுப்பிலிருந்து இயக்குபவர்? இந்த முடிவு நினைவகம் எவ்வாறு நிர்வகிக்கப்படுகிறது மற்றும் விடுவிக்கப்படுகிறது என்பதில் கணிசமான தாக்கத்தை ஏற்படுத்துகிறது, குறிப்பாக தனிப்பட்ட நினைவக மேலாண்மை அல்காரிதம்கள் கொண்ட வகுப்புகளில்.
இந்தக் கட்டுரையில், துணைப்பிரிவுகள் மேலெழுதும்போது, நீக்குதல் ஆபரேட்டர் தேர்வை g++ எவ்வாறு கையாளுகிறது என்பதை நாங்கள் படிப்போம். C++ இயக்க நேரம் எந்த வடிவத்தை தீர்மானிக்கிறது என்பதைக் காட்ட ஒரு உதாரணத்தைப் பயன்படுத்துவோம் பயன்படுத்தப்படுகிறது, மேலும் இது நடைமுறையில் நினைவக நிர்வாகத்தை எவ்வாறு பாதிக்கிறது.
| கட்டளை | பயன்பாட்டின் உதாரணம் |
|---|---|
| operator delete | இது டெலிட் ஆபரேட்டரின் தனிப்பயனாக்கப்பட்ட செயலாக்கமாகும். C++ இல், நீங்கள் மேலெழுதலாம் உங்கள் வகுப்பிற்கான தனிப்பயன் நினைவக பரிமாற்ற நடத்தையை உருவாக்க. ஸ்கிரிப்ட்டில் காணப்படுவது போல், std::free(ptr) ஐப் பயன்படுத்தி நினைவகம் வெளிப்படையாக விடுவிக்கப்படுகிறது. |
| operator new | இதேபோல் , இந்த விருப்ப செயல்படுத்தல் தனிப்பயனாக்கப்பட்ட நினைவக ஒதுக்கீடு நடத்தையை அமைக்க உங்களை அனுமதிக்கிறது. இது std::malloc(size) ஐப் பயன்படுத்தி நினைவகத்தை ஒதுக்கவும், எந்த வகுப்பில் நினைவகத்தை ஒதுக்கியது என்பதைக் குறிப்பிடும் தனிப்பயன் செய்தியை அனுப்பவும் பயன்படுத்தப்பட்டது. |
| virtual destructor | ஒரு பொருளை நீக்குவதற்கு அடிப்படை வகுப்பு சுட்டியைப் பயன்படுத்தும் போது, தி பொருத்தமான அழிப்பவரை அழைக்கிறது. எடுத்துக்காட்டில், X மற்றும் ArenaAllocatedX இரண்டும் மெமரி டீலோகேஷனை சரியாக நிர்வகிக்க மெய்நிகர் அழிப்பான்களைப் பயன்படுத்துகின்றன. |
| gtest | தி அலகு சோதனைகளை உருவாக்க கட்டமைப்பு (GoogleTest) பயன்படுத்தப்படுகிறது. இந்த வழக்கில், அது சரியானதா என சரிபார்க்கிறது ஆபரேட்டர் பயன்படுத்தப்படுகிறது. நினைவக ஒதுக்கீடு மற்றும் இட ஒதுக்கீடு நடவடிக்கைகள் பல்வேறு சூழ்நிலைகளில் விரிவாக சோதிக்கப்படுவதை உறுதி செய்வது மிகவும் முக்கியமானது. |
| ASSERT_EQ | இருந்து இந்த மேக்ரோ இரண்டு மதிப்புகள் சமமாக இருந்தால் நூலகம் சரிபார்க்கிறது, இது பொதுவாக சோதனைக் குறியீட்டில் பயன்படுத்தப்படுகிறது. இந்த விஷயத்தில் எளிமைப்படுத்தப்பட்டாலும், மிகவும் சிக்கலான சோதனையில் நினைவக நிலைகள் அல்லது நீக்குதல் செயல்முறைகளை ஒப்பிடுவதற்கு இது பயன்படுத்தப்படலாம். |
| vptr | vptr என்பது மெய்நிகர் செயல்பாடுகளுடன் வகுப்புகளில் சேர்க்கப்படும் மறைக்கப்பட்ட சுட்டிக்காட்டி ஆகும். இது மெய்நிகர் அட்டவணையை (VTable) சுட்டிக்காட்டுகிறது, இதில் மெய்நிகர் செயல்பாடுகளின் முகவரிகள் உள்ளன. புரிதல் பொருளின் டைனமிக் வகையின் அடிப்படையில் பொருத்தமான நீக்க ஆபரேட்டர் ஏன் அழைக்கப்படுகிறது என்பதை விளக்குகிறது. |
| VTable | ஏ (மெய்நிகர் அட்டவணை) என்பது மெய்நிகர் முறைகளுடன் ஒவ்வொரு வகுப்பிற்கும் மெய்நிகர் செயல்பாடுகளுக்கான குறிப்புகளை பராமரிக்கும் ஒரு கட்டமைப்பாகும். எங்கள் ஸ்கிரிப்டில் பெறப்பட்ட வகுப்புகளுக்கான பொருத்தமான நீக்குதல் ஆபரேட்டரைத் தீர்மானிப்பதில் இது முக்கியமானது. |
| malloc | தி செயல்பாடு மாறும் நினைவகத்தை ஒதுக்குகிறது. தனிப்பயன் நேரடி நினைவக நிர்வாகத்தை வலியுறுத்துவதற்கும், வெவ்வேறு ஒதுக்கீடு அல்காரிதங்களைச் சோதிக்கும் போது அதிக நெகிழ்வுத்தன்மையை வழங்குவதற்கும் புதியதற்குப் பதிலாகப் பயன்படுத்தப்பட்டது. |
நினைவக மேலாண்மை மற்றும் சி++ இல் ஆபரேட்டர் தேர்வை நீக்குதல்
முன்னர் வழங்கப்பட்ட ஸ்கிரிப்ட்கள் C++ எவ்வாறு பொருத்தமானவை என்பதை தீர்மானிக்கிறது துணைப்பிரிவு பொருள்களுடன் பணிபுரியும் போது ஆபரேட்டர். C++ ஓவர்லோட் செய்ய அனுமதிக்கிறது மற்றும் நீக்கவும் தனிப்பயன் நினைவக ஒதுக்கீடு மற்றும் டீல்லோக்கேஷன் அல்காரிதம்களைக் கையாள ஆபரேட்டர்கள். துணைப்பிரிவுகள் அவற்றின் அடிப்படை வகுப்புகளை விட வெவ்வேறு நினைவக மேலாண்மை தேவைகளைக் கொண்டிருக்கும் சந்தர்ப்பங்களில் இது பொருத்தமானது. எடுத்துக்காட்டு ஸ்கிரிப்ட்கள் அடிப்படை வகுப்பை உருவாக்குவதன் மூலம் இதைக் காட்டுகின்றன மற்றும் ஒரு துணைப்பிரிவு ArenaAllocatedX, இரண்டும் தனிப்பயன் செயலாக்கங்களுடன் புதிய மற்றும் நீக்கவும் ஆபரேட்டர்கள்.
முதல் எழுத்தில், தி மற்றும் நினைவக ஒதுக்கீடு மற்றும் விடுவிக்கும் போது குறிப்பிட்ட செய்திகளை உருவாக்க ஆபரேட்டர்கள் அதிக சுமை கொண்டுள்ளனர். அடிப்படை வகுப்பு ஒரு செயல்படுத்தல் உள்ளது, ஆனால் துணைப்பிரிவு ArenaAllocatedX அதை மீறுகிறது. எந்தப் பதிப்பின் எந்தப் பதிப்பை C++ எப்படித் தீர்மானிக்கிறது என்பதுதான் முக்கிய அம்சம் நீக்கவும் ஒரு பொருள் அழிக்கப்படும் போது பயன்படுத்த ஆபரேட்டர். இரண்டுக்கும் சரியான ஆபரேட்டர் அழைக்கப்படுகிறார் எக்ஸ் மற்றும் ArenaAllocatedX, பொருளின் டைனமிக் வகை இதைத் தீர்மானிக்கிறது, சுட்டியின் வகை அல்ல (இது )
இரண்டாவது ஸ்கிரிப்ட் என்ற கருத்தை அறிமுகப்படுத்துகிறது மற்றும் . அழிப்பான்கள் உட்பட மெய்நிகர் செயல்பாடுகளை C++ எவ்வாறு அனுப்புகிறது என்பதைப் புரிந்துகொள்வதற்கு இவை இன்றியமையாதவை. நீக்குதல் ஆபரேட்டர் VTable இல் இல்லை என்றாலும், பொருளின் டைனமிக் வகையின் அடிப்படையில் சரியான நீக்குதல் ஆபரேட்டர் செயல்படுத்தப்படுவதை உறுதி செய்வதில் மெய்நிகர் அழிப்பான் முக்கிய பங்கு வகிக்கிறது. அழிப்பான் உத்தரவாதம் அளிக்கும் போது a சுட்டி சுட்டி a ArenaAllocatedX பொருள், துணைப்பிரிவின் அறுவை சிகிச்சை என்று அழைக்கப்படுகிறது.
இறுதியாக, இறுதி ஸ்கிரிப்ட் GoogleTest கட்டமைப்பைப் பயன்படுத்தி அலகு சோதனைகளைச் சேர்க்கிறது. பல்வேறு சூழல்களில் பொருத்தமான நினைவக மேலாண்மை செயல்பாடுகள் செயல்படுத்தப்படுவதை உறுதி செய்வதற்கு அலகு சோதனை மிகவும் முக்கியமானது. பயன்படுத்துகிறோம் அடிப்படை மற்றும் துணைப்பிரிவு இரண்டும் அந்தந்த ஆபரேட்டர்களைப் பயன்படுத்தி நினைவகத்தை சரியாக ஒதுக்கி நீக்குவதை உறுதி செய்ய. நினைவக கசிவுகள் அல்லது பொருத்தமற்ற இட ஒதுக்கீடுகள் ஏற்படாமல் இருப்பதை உறுதிசெய்ய இது உதவுகிறது, இது டைனமிக் மெமரி மேனேஜ்மென்ட்டை கணிசமாக நம்பியிருக்கும் பயன்பாடுகளில் முக்கியமானது, குறிப்பாக அதிவேகம் தேவைப்படும் மென்பொருளில்.
ஒட்டுமொத்தமாக, இந்த ஸ்கிரிப்டுகள் எவ்வாறு ஆபரேட்டர் ஓவர்லோடிங்கைக் கையாளுகிறது என்பதைக் காட்டுகின்றன, அதே சமயம் மெய்நிகர் அழிப்பான்களின் தேவையையும், பரம்பரை படிநிலைகளில் நினைவகத்தை நிர்வகிக்கும் போது டைனமிக் வகை தீர்மானத்தையும் வலியுறுத்துகிறது. VTable இன் இயக்கவியல் மற்றும் அதன் பங்கைப் புரிந்துகொள்வது ஏன் பொருத்தமானது என்பதை விளக்குகிறது அடிப்படை மற்றும் சிக்கலான வகுப்பு படிநிலைகள் இரண்டிலும் சரியான நினைவக கையாளுதலை உறுதிசெய்து, இயக்க நேரத்தில் ஆபரேட்டர் தேர்ந்தெடுக்கப்படுகிறார்.
நினைவக மேலாண்மை மற்றும் சி++ இல் ஆபரேட்டர் தேர்வை நீக்குதல்
இந்த ஸ்கிரிப்ட், துணைப்பிரிவுகள் மேலெழுதும்போது, நீக்குதல் ஆபரேட்டரை எவ்வாறு தேர்ந்தெடுக்கிறது என்பதை ஆராய, ஒரு சுத்தமான C++ அணுகுமுறையை எடுக்கிறது. வகுப்பு மற்றும் துணைப்பிரிவுகளில் மாற்று ஆபரேட்டர் ஓவர்லோடுகளை சரியான நினைவக மேலாண்மை வழிமுறைகளுடன் சோதிக்கிறோம்.
#include <iostream>#include <cstdlib>struct X {void* operator new(std::size_t size) {std::cout << "new X\n";return std::malloc(size);}void operator delete(void* ptr) {std::cout << "delete X\n";std::free(ptr);}virtual ~X() = default;};struct ArenaAllocatedX : public X {void* operator new(std::size_t size) {std::cout << "new ArenaAllocatedX\n";return std::malloc(size);}void operator delete(void* ptr) {std::cout << "delete ArenaAllocatedX\n";std::free(ptr);}};int main() {X* x1 = new X();delete x1;X* x2 = new ArenaAllocatedX();delete x2;return 0;}
ஆபரேட்டர் நீக்கத்திற்கான சி++ இல் VTable ஆய்வு
இந்த ஸ்கிரிப்ட் விர்ச்சுவல் டேபிள்களை உருவாக்குகிறது மற்றும் டெலிட் ஆபரேட்டர்கள் எப்படி தேர்வு செய்யப்படுகின்றன என்பதை தீர்மானிக்க மெய்நிகர் அழிப்பான்களைப் பயன்படுத்துகிறது. VTable இன் கட்டமைப்பைக் காண g++ கம்பைலரின் கொடிகள் மற்றும் குறிப்பிட்ட நினைவக கையாளுதல் கருவிகள் பயன்படுத்தப்படுகின்றன.
#include <iostream>#include <cstdlib>struct X {virtual ~X() { std::cout << "X destructor\n"; }static void operator delete(void* ptr) {std::cout << "delete X\n";std::free(ptr);}};struct ArenaAllocatedX : public X {virtual ~ArenaAllocatedX() { std::cout << "ArenaAllocatedX destructor\n"; }static void operator delete(void* ptr) {std::cout << "delete ArenaAllocatedX\n";std::free(ptr);}};int main() {X* x1 = new X();delete x1;X* x2 = new ArenaAllocatedX();delete x2;return 0;}
C++ இல் நினைவக கையாளுதலுக்கான அலகு சோதனைகள்
இந்த ஸ்கிரிப்ட் நினைவக ஒதுக்கீடு மற்றும் நீக்குதல் ஆகிய இரண்டிற்கும் யூனிட் சோதனைகளை வழங்குகிறது, ஆபரேட்டர் நீக்கும் முறைகள் சரியாக அழைக்கப்படுவதற்கு உத்தரவாதம் அளிக்க GoogleTest போன்ற C++ சோதனை கட்டமைப்பை நம்பியுள்ளது.
#include <iostream>#include <gtest/gtest.h>struct X {void* operator new(std::size_t size) {return std::malloc(size);}void operator delete(void* ptr) {std::free(ptr);}virtual ~X() = default;};struct ArenaAllocatedX : public X {void* operator new(std::size_t size) {return std::malloc(size);}void operator delete(void* ptr) {std::free(ptr);}virtual ~ArenaAllocatedX() = default;};TEST(MemoryTest, DeleteX) {X* x = new X();delete x;ASSERT_EQ(1, 1); // Simplified check}TEST(MemoryTest, DeleteArenaAllocatedX) {X* x = new ArenaAllocatedX();delete x;ASSERT_EQ(1, 1); // Simplified check}int main(int argc, char argv) {::testing::InitGoogleTest(&argc, argv);return RUN_ALL_TESTS();}
அடிப்படைகளுக்கு அப்பால் நினைவக மேலாண்மையைப் புரிந்துகொள்வது
C++ இல், நினைவக மேலாண்மை என்பது எதைத் தீர்மானிக்கிறது ஒரு பொருள் நீக்கப்படும் போது, குறிப்பாக துணைப்பிரிவு காட்சிகளில் பயன்படுத்த ஆபரேட்டர். இதுபோன்ற சந்தர்ப்பங்களில், இயக்க நேரத்தில் பொருளின் உண்மையான வகையை தீர்மானிக்க, சி++ டைனமிக் டைப்பிங் கருத்தைப் பயன்படுத்துகிறது. இது அவசியமானது, ஏனெனில் ஒரு அடிப்படை வகுப்புக் குறிப்பு பெறப்பட்ட வகுப்பின் பொருளைச் சுட்டிக் காட்டும்போது, பெறப்பட்ட வகுப்பின் அழிப்பான் மற்றும் நீக்கு ஆபரேட்டர் அழைக்கப்பட வேண்டும்.
கொடுக்கப்பட்ட எடுத்துக்காட்டில், அடிப்படை வகுப்பு மற்றும் துணைப்பிரிவு அவர்களின் சொந்த பதிப்புகளை உருவாக்கவும் மற்றும் நீக்கவும் ஆபரேட்டர்கள். ஒரு பொருள் அகற்றப்படும் போது, C++ ஐப் பயன்படுத்தி அதன் வகையைச் சரிபார்க்கிறது (மெய்நிகர் சுட்டிக்காட்டி) நுட்பம். டிஸ்ட்ரக்டர் என்பது மெய்நிகர், நீக்குதல் வரிசையானது துணைப்பிரிவுடன் தொடங்கும் மற்றும் பொருளின் டைனமிக் வகைக்கான சரியான நீக்குதல் செயல்பாட்டைத் தூண்டுகிறது. நினைவக கசிவைத் தடுப்பதற்கும் துணைப்பிரிவால் ஒதுக்கப்பட்ட வளங்கள் சரியான முறையில் வெளியிடப்படுவதை உறுதி செய்வதற்கும் இந்த முறை முக்கியமானது.
இந்த நடத்தையின் மற்றொரு குறிப்பிடத்தக்க அம்சம் என்னவென்றால், C++ நேரடியாக சேமிக்காது மற்றும் இல் உள்ள ஆபரேட்டர்கள் . அதற்கு பதிலாக, இயக்க நேரம் டிஸ்ட்ரக்டரைப் பயன்படுத்தி, பொருத்தமான நீக்குதல் ஆபரேட்டர் செயல்படுத்தப்பட்டதா என்பதைச் சரிபார்க்கிறது. இந்த முறை இல்லாமல், ஒரு அடிப்படை வகுப்பு சுட்டிக்காட்டி வழியாக ஒரு பொருளை அழிப்பது முழுமையற்ற நினைவக டீலோகேஷனை விளைவித்து, வளங்களை நிர்வகிக்காமல் விட்டுவிடும். இது C++ பரம்பரை படிநிலைகளில் மெய்நிகர் அழிப்பான்களின் முக்கியத்துவத்தை வலியுறுத்துகிறது, குறிப்பாக தனிப்பயன் நினைவக ஒதுக்கீடு பயன்படுத்தப்படும் போது.
C++ நினைவக மேலாண்மை பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்
- இதன் நோக்கம் என்ன C++ இல்?
- ஏ அடிப்படை வகுப்பு சுட்டி மூலம் ஒரு பொருள் அகற்றப்படும் போது, பெறப்பட்ட வகுப்பிற்கான அழிப்பான் செயல்படுத்தப்படும் என்று உறுதியளிக்கிறது. இது சரியான வளத்தை சுத்தம் செய்ய அனுமதிக்கிறது.
- செய்கிறது ஆபரேட்டர் VTable இல் சேமிக்கப்படுமா?
- இல்லை, தி ஆபரேட்டர் VTable இல் வைக்கப்படவில்லை. அழிப்பவர் மெய்நிகர், பொருத்தமானது என்பதை உறுதி செய்கிறது ஆப்ஜெக்ட்டின் டைனமிக் வகையின் அடிப்படையில் ஆபரேட்டர் தேர்ந்தெடுக்கப்படுகிறார்.
- C++ எப்படி தீர்மானிக்கிறது ஆபரேட்டர் அழைக்க?
- C++ ஆனது டைனமிக் டைப்பிங்கைப் பயன்படுத்துகிறது (மெய்நிகர் சுட்டிக்காட்டி) பொருத்தமானதைத் தேர்ந்தெடுக்கவும் அழிக்கப்படும் பொருள் வகையின் அடிப்படையில் இயக்குபவர்.
- ஏன் உள்ளது துணைப்பிரிவை நீக்குவதில் முக்கியமா?
- தி டிஸ்ட்ரக்டர் போன்ற மெய்நிகர் செயல்பாடுகளுக்கான முகவரிகளைக் கொண்ட VTable ஐக் குறிக்கிறது. இது பொருத்தமான பதிப்பை உறுதி செய்கிறது ஒரு துணைப்பிரிவு பொருள் அழிக்கப்படும் போது செயல்படுத்தப்படுகிறது.
- இரண்டையும் நான் மீறலாமா மற்றும் C++ இல்?
- மேலெழுதல் மற்றும் எந்த வகுப்பிலும் நினைவகம் எவ்வாறு ஒதுக்கப்படுகிறது மற்றும் விடுவிக்கப்படுகிறது என்பதை மாற்ற அனுமதிக்கிறது, இது எடுத்துக்காட்டில் விளக்கப்பட்டுள்ளது மற்றும் ArenaAllocatedX.
பொருத்தமானதைத் தேர்ந்தெடுப்பது C++ இல் உள்ள ஆபரேட்டருக்கு மெய்நிகர் அழிப்பான்கள் மற்றும் டைனமிக் வகைகள் எவ்வாறு தொடர்பு கொள்கின்றன என்பதைப் புரிந்து கொள்ள வேண்டும். ஒரு துணைப்பிரிவு நினைவக மேலாண்மை செயல்பாடுகளை மீறும் போது, கம்பைலர் பொருத்தமான ஆபரேட்டர் பொருள் அழிவுக்குப் பயன்படுத்தப்படும் என்று உத்தரவாதம் அளிக்கிறது.
இந்த முறை நினைவக கசிவுகளிலிருந்து பாதுகாக்கிறது மற்றும் துணைப்பிரிவு-குறிப்பிட்ட ஆதாரங்கள் சரியாக சுத்தம் செய்யப்படுவதை உறுதி செய்கிறது. எடுத்துக்காட்டுகள் மற்றும் VTable ஆய்வு மூலம், பாடநெறி C++ பரம்பரையின் இந்த முக்கியமான கூறு மற்றும் நினைவக பரிமாற்றத்தை மொழி எவ்வாறு கையாளுகிறது என்பதை விளக்குகிறது.
- தேர்வு தொடர்பான உள்ளடக்கம் C++ இல் உள்ள ஆபரேட்டர்கள் அதிகாரப்பூர்வத்தில் காணப்படும் தகவலின் அடிப்படையில் அமைந்தது C++ குறிப்பு ஆவணங்கள் .
- கம்பைலர் நடத்தை மற்றும் VTable தலைமுறை விவரங்கள் வழங்கிய ஆதாரங்கள் மூலம் ஆராயப்பட்டன GCC ஆவணம் .
- எடுத்துக்காட்டாக குறியீடு சோதிக்கப்பட்டது மற்றும் காட்சிப்படுத்தப்பட்டது கம்பைலர் எக்ஸ்ப்ளோரர் (காட்போல்ட்) பல்வேறு கம்பைலர்கள் முழுவதும் நிகழ்நேர தொகுத்தல் நடத்தையை உருவகப்படுத்தும் கருவி.