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++ કેવી રીતે યોગ્ય નક્કી કરે છે તેના પર ધ્યાન કેન્દ્રિત કરે છે ઑપરેટર જ્યારે સબક્લાસ ઑબ્જેક્ટ્સ સાથે કામ કરે છે. C++ ઓવરલોડિંગ માટે પરવાનગી આપે છે અને કાઢી નાખો કસ્ટમ મેમરી ફાળવણી અને ડીલલોકેશન અલ્ગોરિધમ્સને હેન્ડલ કરવા માટે ઓપરેટરો. આ એવા કિસ્સાઓમાં સંબંધિત છે કે જ્યાં સબક્લાસને તેમના બેઝ ક્લાસ કરતાં અલગ મેમરી મેનેજમેન્ટ આવશ્યકતાઓ હોઈ શકે છે. ઉદાહરણ સ્ક્રિપ્ટો બેઝ ક્લાસ બનાવીને આ દર્શાવે છે અને પેટા વર્ગ ArenaAllocatedX, બંનેના કસ્ટમ અમલીકરણ સાથે નવું અને કાઢી નાખો ઓપરેટરો
પ્રથમ સ્ક્રિપ્ટમાં, ધ અને ઓપરેટરો મેમરી ફાળવણી અને ફ્રીિંગ દરમિયાન ઉલ્લેખિત સંદેશાઓ બનાવવા માટે ઓવરલોડ થાય છે. આધાર વર્ગ એક અમલીકરણ છે, પરંતુ પેટા વર્ગ ArenaAllocatedX તેને ઓવરરાઇડ કરે છે. મુખ્ય ટેકઅવે એ છે કે કેવી રીતે C++ નું કયું સંસ્કરણ નક્કી કરે છે કાઢી નાખો ઑપરેટર જ્યારે ઑબ્જેક્ટ નાશ પામે ત્યારે વાપરવા માટે. બંને માટે યોગ્ય ઓપરેટરને બોલાવવામાં આવે છે એક્સ અને ArenaAllocatedX, કારણ કે ઑબ્જેક્ટનો ગતિશીલ પ્રકાર આને નિર્ધારિત કરે છે, નિર્દેશકનો પ્રકાર નહીં (જે ).
બીજી સ્ક્રિપ્ટ ની કલ્પના રજૂ કરે છે અને . C++ વર્ચ્યુઅલ ફંક્શનને ડિસ્ટ્રક્ટર સહિત કેવી રીતે ડિસ્પેચ કરે છે તે સમજવા માટે આ મહત્વપૂર્ણ છે. ડીલીટ ઓપરેટર VTable માં સમાયેલ ન હોવા છતાં, વર્ચ્યુઅલ ડિસ્ટ્રક્ટર એ ખાતરી કરવા માટે નિર્ણાયક ભૂમિકા ભજવે છે કે ઑબ્જેક્ટના ડાયનેમિક પ્રકારને આધારે યોગ્ય ડિલીટ ઓપરેટરનો ઉપયોગ કરવામાં આવે છે. વિનાશક ખાતરી આપે છે કે જ્યારે એ નિર્દેશક એ તરફ નિર્દેશ કરે છે ArenaAllocatedX ઑબ્જેક્ટ, પેટા વર્ગનું ઓપરેશન કહેવાય છે.
છેલ્લે, અંતિમ સ્ક્રિપ્ટ GoogleTest ફ્રેમવર્કનો ઉપયોગ કરીને એકમ પરીક્ષણો ઉમેરે છે. એકમ પરીક્ષણ એ સુનિશ્ચિત કરવા માટે મહત્વપૂર્ણ છે કે યોગ્ય મેમરી મેનેજમેન્ટ કાર્યો વિવિધ સંદર્ભોમાં ચલાવવામાં આવે છે. અમે ઉપયોગ કરીએ છીએ ખાતરી કરવા માટે કે બેઝ અને સબક્લાસ બંને તેમના સંબંધિત ઓપરેટરોનો ઉપયોગ કરીને મેમરીને યોગ્ય રીતે ફાળવે છે અને કાઢી નાખે છે. આ એ સુનિશ્ચિત કરવામાં મદદ કરે છે કે કોઈ મેમરી લીક અથવા અયોગ્ય ડીલલોકેશન થતું નથી, જે એપ્લીકેશનમાં મહત્વપૂર્ણ છે જે ડાયનેમિક મેમરી મેનેજમેન્ટ પર નોંધપાત્ર રીતે આધાર રાખે છે, ખાસ કરીને સૉફ્ટવેરમાં કે જેને ઉચ્ચ ગતિની જરૂર હોય છે.
એકંદરે, આ સ્ક્રિપ્ટો બતાવે છે કે કેવી રીતે C++ ઓપરેટર ઓવરલોડિંગને હેન્ડલ કરે છે જ્યારે વારસાગત વંશવેલોમાં મેમરીનું સંચાલન કરતી વખતે વર્ચ્યુઅલ ડિસ્ટ્રક્ટર અને ડાયનેમિક પ્રકાર નિર્ધારણની જરૂરિયાત પર પણ ભાર મૂકે છે. VTable ના મિકેનિક્સ અને ની ભૂમિકા સમજવી શા માટે યોગ્ય છે તે સમજાવે છે ઑપરેટર રનટાઇમ પર પસંદ કરવામાં આવે છે, મૂળભૂત અને જટિલ વર્ગ વંશવેલો બંનેમાં યોગ્ય મેમરી હેન્ડલિંગની ખાતરી કરે છે.
C++ માં મેમરી મેનેજમેન્ટ અને ડિલીટ ઓપરેટર પસંદગી
જ્યારે ઉપવર્ગો તેને ઓવરરાઇડ કરે છે ત્યારે ડિલીટ ઓપરેટર કેવી રીતે પસંદ કરવામાં આવે છે તેની તપાસ કરવા માટે આ સ્ક્રિપ્ટ શુદ્ધ 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;}
ઓપરેટર ડિલીટ માટે C++ માં VTable એક્સપ્લોરેશન
આ સ્ક્રિપ્ટ વર્ચ્યુઅલ કોષ્ટકો જનરેટ કરે છે અને ડિલીટ ઓપરેટર્સ કેવી રીતે પસંદ કરવામાં આવે છે તે નક્કી કરવા માટે વર્ચ્યુઅલ ડિસ્ટ્રક્ટરનો ઉપયોગ કરે છે. G++ કમ્પાઇલરના ફ્લેગ્સ અને ચોક્કસ મેમરી હેન્ડલિંગ ટૂલ્સનો ઉપયોગ VTableનું માળખું જોવા માટે થાય છે.
#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++ મેમરી મેનેજમેન્ટ વિશે વારંવાર પૂછાતા પ્રશ્નો
- નો હેતુ શું છે C++ માં?
- એ ખાતરી આપે છે કે જ્યારે ઑબ્જેક્ટને બેઝ ક્લાસ પોઇન્ટર દ્વારા દૂર કરવામાં આવે છે, ત્યારે વ્યુત્પન્ન વર્ગ માટે ડિસ્ટ્રક્ટરને બોલાવવામાં આવે છે. આ યોગ્ય સંસાધન સફાઈની મંજૂરી આપે છે.
- કરે છે ઓપરેટર VTable માં સંગ્રહિત થાય છે?
- ના, ધ ઓપરેટર VTable માં રાખવામાં આવેલ નથી. ડિસ્ટ્રક્ટર વર્ચ્યુઅલ છે, તે સુનિશ્ચિત કરે છે કે તે યોગ્ય છે ઑપરેટર ઑબ્જેક્ટના ડાયનેમિક પ્રકારને આધારે પસંદ કરવામાં આવે છે.
- C++ કઈ રીતે નક્કી કરે છે ઓપરેટરને કૉલ કરવો છે?
- C++ દ્વારા ડાયનેમિક ટાઇપિંગનો ઉપયોગ કરે છે (વર્ચ્યુઅલ પોઇન્ટર) યોગ્ય પસંદ કરવા માટે ઑબ્જેક્ટ પ્રકાર પર આધારિત ઑપરેટર ભૂંસી નાખવામાં આવે છે.
- શા માટે છે પેટા વર્ગ કાઢી નાખવામાં મહત્વપૂર્ણ છે?
- આ VTable નો સંદર્ભ આપે છે, જેમાં ડિસ્ટ્રક્ટર જેવા વર્ચ્યુઅલ ફંક્શન માટે સરનામાંઓ શામેલ છે. આ સુનિશ્ચિત કરે છે કે નું યોગ્ય સંસ્કરણ જ્યારે સબક્લાસ ઑબ્જેક્ટ ભૂંસી નાખવામાં આવે ત્યારે ચલાવવામાં આવે છે.
- શું હું બંનેને ઓવરરાઇડ કરી શકું છું અને C++ માં?
- ઓવરરાઇડિંગ અને કોઈપણ વર્ગમાં તમને મેમરી કેવી રીતે ફાળવવામાં આવે છે અને મુક્ત કરવામાં આવે છે તે બદલવાની મંજૂરી આપે છે, જેમ કે સાથેના ઉદાહરણમાં સચિત્ર છે અને ArenaAllocatedX.
યોગ્ય પસંદ કરી રહ્યા છીએ C++ માં ઓપરેટરને સમજવું જરૂરી છે કે વર્ચ્યુઅલ ડિસ્ટ્રક્ટર અને ડાયનેમિક પ્રકારો કેવી રીતે ક્રિયાપ્રતિક્રિયા કરે છે. જ્યારે સબક્લાસ મેમરી મેનેજમેન્ટ ફંક્શન્સને ઓવરરાઇડ કરે છે, ત્યારે કમ્પાઇલર ખાતરી આપે છે કે ઑબ્જેક્ટના વિનાશ માટે યોગ્ય ઑપરેટરનો ઉપયોગ થાય છે.
આ પદ્ધતિ મેમરી લીક સામે રક્ષણ આપે છે અને ખાતરી આપે છે કે સબક્લાસ-વિશિષ્ટ સ્ત્રોતો યોગ્ય રીતે સાફ થઈ ગયા છે. ઉદાહરણો અને VTable અન્વેષણ દ્વારા, કોર્સ C++ વારસાના આ નિર્ણાયક ઘટકને પ્રકાશિત કરે છે અને ભાષા કેવી રીતે મેમરી ડીલલોકેશનને હેન્ડલ કરે છે.
- ની પસંદગી અંગેની સામગ્રી C++ માં ઓપરેટરો અધિકારીમાં મળેલી માહિતી પર આધારિત હતા C++ સંદર્ભ દસ્તાવેજીકરણ .
- દ્વારા પૂરા પાડવામાં આવેલ સંસાધનો દ્વારા કમ્પાઈલર વર્તન અને VTable જનરેશન વિગતોની શોધ કરવામાં આવી હતી GCC દસ્તાવેજીકરણ .
- ઉદાહરણ કોડનો ઉપયોગ કરીને પરીક્ષણ અને વિઝ્યુઅલાઈઝ કરવામાં આવ્યું હતું કમ્પાઈલર એક્સપ્લોરર (ગોડબોલ્ટ) ટૂલ, જે વિવિધ કમ્પાઇલરોમાં રીઅલ-ટાઇમ સંકલન વર્તનનું અનુકરણ કરે છે.