नए / डिलीट और मॉलोक / फ्री में क्या अंतर है?

Question

new/ deleteऔर malloc/ के बीच क्या अंतर है free?

संबंधित (डुप्लिकेट?): किन मामलों में मैं मॉलोक बनाम नए का उपयोग करता हूं?

Comments

मेरा विस्तृत जवाब यहां भी देखें ।

— जोनाथन एच

Answer 1

नई / हटाएँ

• स्मृति आवंटित / जारी करें
  1. 'फ्री स्टोर' से आवंटित मेमोरी
  2. पूरी तरह से टाइप किए गए पॉइंटर को लौटाता है।
  3. नया (मानक संस्करण) कभी NULL नहीं लौटाता (विफलता पर फेंक देगा)
  4. टाइप-आईडी के साथ कहा जाता है (संकलक आकार की गणना करता है)
  5. सरणियों को संभालने के लिए स्पष्ट रूप से एक संस्करण है।
  6. Reallocating (अधिक स्थान प्राप्त करने के लिए) सहज रूप से संभाला नहीं गया (कॉपी कंस्ट्रक्टर के कारण)।
  7. चाहे वे मॉलॉक / फ्री कहते हैं, कार्यान्वयन को परिभाषित किया गया है।
  8. कम मेमोरी (set_new_handler) से निपटने के लिए एक नया मेमोरी एलोकेटर जोड़ सकते हैं
  9. ऑपरेटर नया / हटाए जाने को कानूनी रूप से ओवरराइड किया जा सकता है
  10. कंस्ट्रक्टर / डिस्ट्रक्टर का उपयोग ऑब्जेक्ट को इनिशियलाइज़ / नष्ट करने के लिए किया जाता है

malloc / मुक्त

• स्मृति आवंटित / जारी करें
  1. 'हीप' से आवंटित मेमोरी
  2. एक शून्य देता है *
  3. विफलता पर पूर्ण रिटर्न
  4. बाइट्स में आवश्यक आकार निर्दिष्ट करना चाहिए।
  5. आबंटन सरणी को अंतरिक्ष की मैन्युअल गणना की आवश्यकता होती है।
  6. मेमोरी सरल के बड़े हिस्से को पुनः लोड करना (चिंता करने के लिए कोई कॉपी कंस्ट्रक्टर नहीं)
  7. वे नई कॉल नहीं करेंगे / हटाएं
  8. कम मेमोरी के साथ उपयोगकर्ता कोड को आवंटन अनुक्रम में विभाजित करने का कोई तरीका नहीं।
  9. मॉलॉक / निःशुल्क कानूनी रूप से अधिभूत नहीं हो सकते

सुविधाओं की तुलना तालिका:

 Feature                  | new/delete                     | malloc/free                   
--------------------------+--------------------------------+-------------------------------
 Memory allocated from    | 'Free Store'                   | 'Heap'                        
 Returns                  | Fully typed pointer            | void*                         
 On failure               | Throws (never returns NULL)    | Returns NULL                  
 Required size            | Calculated by compiler         | Must be specified in bytes    
 Handling arrays          | Has an explicit version        | Requires manual calculations  
 Reallocating             | Not handled intuitively        | Simple (no copy constructor)  
 Call of reverse          | Implementation defined         | No                            
 Low memory cases         | Can add a new memory allocator | Not handled by user code      
 Overridable              | Yes                            | No                            
 Use of (con-)/destructor | Yes                            | No                            

तकनीकी रूप से नई द्वारा आवंटित की गई मेमोरी 'फ्री स्टोर' से आती है जबकि मॉलॉक द्वारा आवंटित मेमोरी 'हीप' से आती है। क्या ये दोनों क्षेत्र समान हैं एक कार्यान्वयन विवरण है, जो एक और कारण है कि मॉलोक और नए को मिश्रित नहीं किया जा सकता है।

Comments

क्या कोई "ढेर के विपरीत" फ्री स्टोर के बारे में विस्तार से बता सकता है? एक प्रक्रिया 'ढेर एक प्रसिद्ध भाषा-स्वतंत्र (?) ऑपरेटिंग-सिस्टम-स्तरीय अवधारणा है; "फ्री स्टोर" कहाँ से आता है?

— einpoklum

@einpoklum: वे सिर्फ स्मृति क्षेत्रों के नाम हैं। न तो "हीप" के रूप में जानी जाने वाली भाषा की अवधारणा या "प्रक्रिया हीप" के ओएस अवधारणा से कोई लेना-देना है। सी ++ को जानबूझकर प्लेटफ़ॉर्म / ओएस / कंपाइलर तटस्थ के रूप में परिभाषित किया गया है। तो "प्रक्रियाओं हीप" जैसी एक विशिष्ट ओएस अवधारणा का उपयोग मानक के लचीलेपन को कम करेगा।

— मार्टिन यॉर्क

@winterlight: यह सच हुआ करता था लेकिन अब नहीं है। देखें: linux.die.net/man/3/free If ptr is NULL, no operation is performed.

— मार्टिन यॉर्क

@ लोकीअस्टारी ऐसा लगता है कि 'हीप', 'फ्री स्टोर', और 'डायनेमिक मेमोरी / स्टोरेज' पर्यायवाची हैं: ब्रेज़न स्ट्रॉस्ट्रुप के ए टूर ऑफ़ सी ++ में , वे कहते हैं, " newऑपरेटर फ्री स्टोर से मेमोरी आवंटित करता है (जिसे डायनामिक मेमोरी के रूप में भी जाना जाता है) और ढेर )। गतिशील भंडारण पर सी ++ 14 मानक, खंड 3.7.4 का कहना है कि "वस्तुओं को प्रोग्राम एक्जीक्यूटिव (1.9) के दौरान गतिशील रूप से बनाया जा सकता है, नए-भावों (5.3.4) का उपयोग करके, और डिलीट-एक्सप्रेशंस का उपयोग करके नष्ट कर दिया जाता है।"

— मैक्स हेबर

@ मेहेइबर: इसका मतलब है कि वे समान हो सकते हैं। और कई कार्यान्वयन मॉलोक को कॉल करके नया लागू करते हैं (ध्यान दें कि आसपास का दूसरा तरीका स्पष्ट रूप से अनुमति नहीं है)। लेकिन कई कार्यान्वयन उन मेमोरी क्षेत्रों को पूरी तरह से अलग रखते हैं। उन्हें अलग रखने का कारण यह भी है कि इससे C ++ मेमोरी मैनेजमेंट कोड को C मेमोरी प्रबंधन की तुलना में अलग तरीके से ऑप्टिमाइज़ किया जा सकता है। मुद्दा यह है: वे समान हो सकते हैं लेकिन आप यह नहीं मान सकते कि वे हैं।

— मार्टिन

Answer 2

सबसे अधिक प्रासंगिक अंतर यह है कि newऑपरेटर मेमोरी आवंटित करता है, फिर कंस्ट्रक्टर को कॉल करता है, और deleteविध्वंसक को कॉल करता है और फिर मेमोरी को हटा देता है।

Comments

कड़ाई से बोलते हुए, नया ऑपरेटर सिर्फ मेमोरी आवंटित करता है। यह नई अभिव्यक्ति है जो नए ऑपरेटर को बुलाता है, फिर आवंटित मेमोरी में कंस्ट्रक्टर चलाता है।

— डॉन वेकफील्ड

एक अन्य अंतर यह है कि स्मृति कहाँ आवंटित की जाती है। मैंने हाल ही में कहीं देखा है कि मॉलोक / ढेर पर मुफ्त संचालित होता है, जबकि मेमोरी के किसी अन्य क्षेत्र में नया / डिलीट ऑपरेशन संचालित होता है जिसका नाम अब मुझे मिल जाता है। (यह कहने के लिए पर्याप्त है, हालांकि, उस अन्य क्षेत्र को शायद एक और ढेर के रूप में सोचा जा सकता है।)

— रोबह

@ एमजीबी: हां आप सही हैं कि ऑब्जेक्ट "एप्लिकेशन हीप" या स्टैक पर आवंटित किए जाते हैं। लेकिन @RobH यह उल्लेख कर रहा है कि मानक "एप्लिकेशन हीप" के विभिन्न भागों को क्या कहता है। वहाँ "हीप" है, जहाँ से मॉलोक मेमोरी को और "फ्री स्टोर" को आवंटित करता है, जहाँ से नई मेमोरी आवंटित होती है। हालांकि कुछ कार्यान्वयन में ये क्षेत्र ओवरलैप करते हैं (यह एक कार्यान्वयन विवरण है)।

— मार्टिन यॉर्क

आपका कथन 100% सही है, लेकिन केवल पूछे गए प्रश्न का उत्तर नहीं देता है, नीचे दिए गए उत्तर को देखें, एक कारण है कि यह आपके मुकाबले अधिक वोट देता है।

— मुरली

मैं यह कहने की कोशिश कर रहा था कि कम से कम इसके लिए मॉलोक / फ्री का कुछ उल्लेख होना चाहिए, जो कि आपके उत्तर की कमी के कारण है। फिर भी, यह एक प्रासंगिक और सटीक कथन है, इसलिए मुझे उम्मीद है कि आप मेरी बात समझेंगे। वैसे भी, यदि केवल एसओ ने मुझे अपना पद छोड़ने की अनुमति दी, तो मैं तहे दिल से करूंगा।

— मुरली

Answer 3

newऑब्जेक्ट के ctor को deleteकॉल करता है, dtor को कॉल करता है।

mallocऔर freeबस का आवंटन और कच्चे स्मृति को छोड़ दें।

Comments

कच्ची याद से आपका क्या मतलब है?

— विध्वंसक

रॉ मेमोरी में कुछ भी नहीं किया गया था। इसमें अभी तक किसी भी वस्तु का निर्माण नहीं किया गया है, इसमें कुछ भी कॉपी नहीं किया गया है, और ज्यादातर मामलों में, पिछली सामग्री को अधिलेखित नहीं किया गया है।

— जेम्स कर्रान

Answer 4

new/ deleteC ++ है, malloc/ freeअच्छे पुराने C से आता है।

C ++ में, newऑब्जेक्ट्स कन्स्ट्रक्टर को deleteकॉल करता है और डिस्ट्रक्टर को कॉल करता है।

mallocऔर free, OO से पहले के अंधेरे युगों से आते हैं, केवल ऑब्जेक्ट के किसी भी कोड को निष्पादित किए बिना, मेमोरी आवंटित और मुक्त करते हैं।

Comments

"ऊ से पहले के अंधेरे युगों से आ रहा है" ऐसा लगता है जैसे आप लगा रहे हैं कि नए / हटाएं मॉलोक / फ्री से बेहतर हैं जब वास्तविकता में, न तो बेहतर होता है और न ही खराब होता है, उनके बस अलग-अलग उपयोग होते हैं। ध्यान दें कि मैं ऐसा नहीं हूँ जो आपको नीचा दिखाए, मैं सिर्फ अनुमान लगा रहा हूँ।

— ग्रीम पेरो

Answer 5

C ++ new/ deleteनिर्माता / नाशक तदनुसार कहते हैं।

malloc/ freeबस ढेर से मेमोरी आवंटित करें। new/ deleteसाथ ही मेमोरी आवंटित करें।

Answer 6

एकमात्र समानता यह है कि malloc/ newदोनों एक पॉइंटर लौटाते हैं जो ढेर पर कुछ मेमोरी को संबोधित करता है, और वे दोनों गारंटी देते हैं कि एक बार मेमोरी के इस तरह के ब्लॉक को वापस कर दिया गया है, यह तब तक वापस नहीं आएगा जब तक कि आप इसे पहले खाली / हटा नहीं देते। यही है, वे दोनों "स्मृति आवंटित" करते हैं।

हालांकि, new/ delete, इसके अलावा में मनमाने ढंग से अन्य काम करने कंस्ट्रक्टर्स, विनाशकर्ता और ऑपरेटर ओवरलोडिंग के माध्यम से। malloc/ freeकेवल कभी आवंटित और मुक्त स्मृति।

वास्तव में, newपर्याप्त रूप से अनुकूलन योग्य है कि यह जरूरी नहीं है कि मेमोरी को ढेर से वापस लौटाएं, या यहां तक ​​कि स्मृति को आवंटित करें। हालाँकि डिफ़ॉल्ट newकरता है।

Answer 7

नए और मॉलोक के बीच मुख्य अंतर यह है कि नया ऑब्जेक्ट के निर्माता को आमंत्रित करता है और ऑब्जेक्ट को नष्ट करने के लिए संबंधित कॉल को नष्ट करता है।

अन्य अंतर हैं:

• newप्रकार-सुरक्षित है, mallocप्रकार की वस्तुएँ लौटाता हैvoid*

• newत्रुटि पर एक अपवाद फेंकता है, mallocरिटर्न NULLऔर गलत सेट करता है

• newएक ऑपरेटर है और इसे ओवरलोड किया जा सकता है, mallocएक फ़ंक्शन है और इसे ओवरलोड नहीं किया जा सकता है

• new[], जो सरणियों का आवंटन करता है, की तुलना में अधिक सहज और सुरक्षित है malloc

• mallocव्युत्पन्न आवंटन के माध्यम से आकार दिया जा सकता realloc, newव्युत्पन्न आवंटन आकार नहीं बदला जा सकता है

• mallocप्रकारों newकी एक सरणी आवंटित करने के लिए कहा जाना चाहिए , स्मृति के एक एन-बाइट हिस्सा आवंटित कर सकते charहैं

मतभेदों को देखते हुए, एक सारांश है मॉलॉक सी-एस्क, नया है सी ++ - एस्क। अपने कोड आधार के लिए सही महसूस करने वाले का उपयोग करें।

हालाँकि, यह नए और मॉलोक के लिए अलग-अलग मेमोरी एलोकेशन एल्गोरिदम का उपयोग करके लागू किया जाना है, लेकिन अधिकांश सिस्टमों में आंतरिक रूप से मॉलोक का उपयोग करके लागू किया जाता है, कोई सिस्टम-स्तरीय अंतर नहीं देता है।

Answer 8

कुछ चीजें हैं जो कर रहे हैं newकि करता है mallocनहीं करता है:

1. new उस ऑब्जेक्ट के कंस्ट्रक्टर को कॉल करके ऑब्जेक्ट का निर्माण करता है
2. new आवंटित मेमोरी के टाइपकास्टिंग की आवश्यकता नहीं है।
3. इसे आवंटित करने के लिए स्मृति की मात्रा की आवश्यकता नहीं होती है, बल्कि इसके लिए कई वस्तुओं का निर्माण करना पड़ता है।

इसलिए, यदि आप उपयोग करते हैं malloc, तो आपको स्पष्ट रूप से उपरोक्त चीजों को करने की आवश्यकता है, जो हमेशा व्यावहारिक नहीं होता है। इसके अतिरिक्त, newअतिभारित किया जा सकता है लेकिन mallocनहीं किया जा सकता है।

एक शब्द में, यदि आप C ++ का उपयोग करते हैं, तो newजितना संभव हो उतना उपयोग करने का प्रयास करें ।

Answer 9

भी,

वैश्विक नए और हटाए जाने की अनुमति दी जा सकती है, मॉलोक / मुक्त नहीं हो सकता।

आगे और अधिक नए और हटाए जाने को प्रति प्रकार से ओवरराइड किया जा सकता है।

Answer 10

newऔर deleteC ++ प्राइमेटिव हैं जो एक वर्ग की नई आवृत्ति की घोषणा करते हैं या इसे हटाते हैं (इस प्रकार उदाहरण के लिए वर्ग के विनाशकर्ता को लागू करते हैं)।

mallocऔर freeसी फ़ंक्शन हैं और वे मेमोरी ब्लॉक (आकार में) आवंटित और मुक्त करते हैं।

दोनों आवंटन बनाने के लिए ढेर का उपयोग करते हैं। mallocऔर freeफिर भी अधिक "निम्न स्तर" के रूप में वे सिर्फ स्मृति स्थान का एक हिस्सा आरक्षित करते हैं जो संभवतः एक पॉइंटर के साथ जुड़ा होगा। उस मेमोरी के आसपास कोई संरचना नहीं बनाई जाती है (जब तक कि आप सी सरणी को एक संरचना नहीं मानते हैं)।

Comments

C ++ में नया वर्ग की आवृत्ति घोषित नहीं करता है। यह (आमतौर पर) एक ढेर से आवंटित करता है, और यह कुछ भी घोषित नहीं करता है। आप केवल घोषणा करके एक उदाहरण की घोषणा कर सकते हैं, जिस स्थिति में यह स्टैक पर होगा, या ग्लोबल्स में, घोषणा की भंडारण अवधि के आधार पर।

— स्टीव जेसप

खैर, यह वर्ग के लिए मेमोरी स्पेस आवंटित करता है, लेकिन आप स्टैक में एक क्लास को "घोषित" नहीं कर सकते, न कि स्टैक में क्लास को स्टोर करने के वास्तविक अर्थ में। घोषणा में कक्षा के लिए सिर्फ पॉइंटर शामिल होता है जो हमेशा स्टैक में आवंटित होता है जो वास्तविक मेमोरी को वर्ग में रखता है।

— जॉर्ज कॉर्डोबा

हाँ तुम कर सकते हो। प्रश्न टैग के अनुसार यह C ++ है, इसलिए ऑब्जेक्ट्स स्टैक पर जा सकते हैं। और नई एक घोषणा नहीं है, यह एक अभिव्यक्ति है। किसी चीज की घोषणा करना और उसे आवंटित करना अलग चीजें हैं।

— स्टीव जेसोप

Answer 11

नए और हटाना c ++ में ऑपरेटर हैं; जिसे ओवरलोड भी किया जा सकता है। मॉलॉक और मुक्त सी में कार्य कर रहे हैं;

जब नया थ्रो अपवाद होता है तो मॉलॉक शून्य ptr देता है।

मॉलॉक द्वारा दिए गए पते को फिर से टाइप करके डाला जाना चाहिए क्योंकि यह (शून्य *) मॉलोक (आकार) वापस लौटाता है।

Answer 12

• नया एक ऑपरेटर है, जबकि मॉलोक () एक फ्यूकंटियन है।
• नए रिटर्न सटीक डेटा प्रकार, जबकि मॉलोक () रिटर्न शून्य * (प्रकार शून्य का सूचक)।
• मॉलॉक (), मेमोरी आरंभीकृत नहीं है और डिफ़ॉल्ट मान कचरा है, जबकि नए के मामले में, मेमोरी को डिफ़ॉल्ट मान के साथ आरम्भ किया जाता है, जैसे कि इंट में होने पर 'शून्य (0)' के साथ।
• डिलीट और फ्री () दोनों का उपयोग 'NULL' पॉइंटर्स के लिए किया जा सकता है।

Answer 13

• का उपयोग करने के लिए malloc(), हमें उस कार्यक्रम में शामिल होना चाहिए <stdlib.h> या <alloc.h>जिसके लिए आवश्यक नहीं है new।
• newऔर deleteअतिभारित किया जा सकता है, लेकिन mallocनहीं किया जा सकता है।
• प्लेसमेंट का उपयोग करते हुए new, हम उस पते को पास कर सकते हैं जहां हम मेमोरी आवंटित करना चाहते हैं, लेकिन इसके मामले में यह संभव नहीं है malloc।

Comments

alloc.hएक मानक हेडर नहीं है। <new>प्लेसमेंट नए का उपयोग करना आवश्यक है।

— MM

Answer 14

यह कोड डिलीट कीवर्ड या फ्री फंक्शन के उपयोग के लिए है। लेकिन जब 'मॉलॉक' या 'नई' का उपयोग कर एक पॉइंटर ऑब्जेक्ट बनाते हैं और डिलीट का उपयोग करके ऑब्जेक्ट मेमोरी को डील करते हैं तब भी ऑब्जेक्ट पॉइंटर को क्लास में कॉल फंक्शन हो सकता है। इसके बाद डिलीट के बजाय फ्री का उपयोग करें फिर यह भी फ्री स्टेटमेंट के बाद काम करता है, लेकिन जब दोनों तब केवल पॉइंटर ऑब्जेक्ट को क्लास में काम करने के लिए कॉल नहीं कर सकते .. कोड इस प्रकार है:

#include<iostream>


using namespace std;

class ABC{
public: ABC(){
    cout<<"Hello"<<endl;
  }

  void disp(){
    cout<<"Hi\n";
  }

};

int main(){

ABC* b=(ABC*)malloc(sizeof(ABC));
int* q = new int[20];
ABC *a=new ABC();
b->disp();

cout<<b<<endl;
free(b);
delete b;
//a=NULL;
b->disp();
ABC();
cout<<b;
return 0;
}

आउटपुट:

Hello
Hi
0x2abfef37cc20

Answer 15

1. कुछ सिंटेक्स मॉलॉक की तुलना में सरल है ()

2.new/delete एक ऑपरेटर है जहां मॉलोक () / मुक्त () एक फ़ंक्शन है।

3.new/delete मॉलोक () / मुक्त () की तुलना में तेज़ी से निष्पादित होता है क्योंकि कंपाइलर द्वारा सीधे नए असेंबल कोड को चिपकाया जाता है।

4. हम ऑपरेटर ओवरलैडिंग की मदद से प्रोग्राम में नया / डिलीट अर्थ बदल सकते हैं।