ความแตกต่างระหว่างใหม่ / ลบและ malloc / ฟรีคืออะไร?

ความแตกต่างระหว่างnew/ deleteและmalloc/ freeคืออะไร?

ที่เกี่ยวข้อง (ซ้ำกัน?): ฉันจะใช้ malloc กับ new ในกรณีใดบ้าง

ใหม่ / ลบ

• จัดสรร / ปล่อยหน่วยความจำ
  1. หน่วยความจำที่จัดสรรจาก 'ร้านค้าฟรี'
  2. ส่งคืนตัวชี้ที่พิมพ์อย่างสมบูรณ์
  3. ใหม่ (รุ่นมาตรฐาน) จะไม่ส่งคืน NULL (จะเกิดความล้มเหลว)
  4. ถูกเรียกด้วย Type-ID (คอมไพเลอร์คำนวณขนาด)
  5. มีเวอร์ชันอย่างชัดเจนเพื่อจัดการอาร์เรย์
  6. การจัดสรรใหม่ (เพื่อให้มีพื้นที่มากขึ้น) ไม่ได้รับการจัดการโดยสังหรณ์ใจ (เนื่องจากตัวสร้างสำเนา)
  7. ไม่ว่าพวกเขาจะเรียกใช้ malloc / free หรือไม่ก็ตาม
  8. สามารถเพิ่มตัวจัดสรรหน่วยความจำใหม่เพื่อจัดการกับหน่วยความจำเหลือน้อย (set_new_handler)
  9. ผู้ประกอบการใหม่ / ลบสามารถถูกแทนที่ตามกฎหมาย
  10. ตัวสร้าง / destructor ที่ใช้ในการเริ่มต้น / ทำลายวัตถุ

malloc / ฟรี

• จัดสรร / ปล่อยหน่วยความจำ
  1. หน่วยความจำที่จัดสรรจาก 'ฮีป'
  2. ส่งคืนช่องว่าง *
  3. ส่งคืน NULL เมื่อเกิดความล้มเหลว
  4. ต้องระบุขนาดที่ต้องการในหน่วยไบต์
  5. การจัดสรรอาร์เรย์ต้องการการคำนวณพื้นที่ด้วยตนเอง
  6. จัดสรรหน่วยความจำขนาดใหญ่ได้ง่าย ๆ (ไม่มีตัวสร้างสำเนาที่ต้องกังวล)
  7. พวกเขาจะไม่เรียกใหม่ / ลบ
  8. ไม่มีวิธีการประกบรหัสผู้ใช้ในลำดับการจัดสรรเพื่อช่วยในหน่วยความจำเหลือน้อย
  9. malloc / free ไม่สามารถเขียนทับได้อย่างถูกกฎหมาย

ตารางเปรียบเทียบคุณสมบัติ:

 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                            

หน่วยความจำทางเทคนิคที่จัดสรรโดยใหม่มาจาก 'Free Store' ในขณะที่หน่วยความจำที่จัดสรรโดย malloc มาจาก 'Heap' ไม่ว่าทั้งสองพื้นที่จะเหมือนกันหรือไม่เป็นรายละเอียดการใช้งานซึ่งเป็นอีกเหตุผลหนึ่งที่ malloc และใหม่ไม่สามารถผสมกันได้

ความแตกต่างที่เกี่ยวข้องมากที่สุดคือnewผู้ประกอบการจัดสรรหน่วยความจำจากนั้นเรียกตัวสร้างและdeleteเรียก destructor แล้วจัดสรรหน่วยความจำ

newเรียก ctor ของวัตถุdeleteเรียก dtor

malloc& freeจัดสรรและปล่อยหน่วยความจำดิบ

new/ deleteคือ C ++, malloc/ freeมาจาก C เก่าที่ดี

ใน C ++ newเรียกใช้ตัวสร้างวัตถุและdeleteเรียก destructor

mallocและfreeมาจากยุคมืดก่อน OO เท่านั้นจัดสรรและเพิ่มหน่วยความจำโดยไม่ต้องใช้รหัสของวัตถุใด ๆ

ใน C ++ new/ deleteเรียก Constructor / Destructor ตามลำดับ

malloc/ freeเพียงจัดสรรหน่วยความจำจากฮีป new/ deleteจัดสรรหน่วยความจำเช่นกัน

ความคล้ายคลึงกันเพียงอย่างเดียวคือmalloc/ newทั้งคู่ส่งคืนตัวชี้ซึ่งระบุถึงหน่วยความจำบางส่วนบนฮีปและทั้งคู่รับประกันว่าเมื่อมีการส่งคืนบล็อกหน่วยความจำดังกล่าวแล้วจะไม่ถูกส่งคืนอีกเว้นแต่คุณจะว่าง / ลบก่อน นั่นคือพวกเขาทั้งสอง "จัดสรร" หน่วยความจำ

อย่างไรก็ตามnew/ deleteทำงานโดยพลการอื่นนอกจากนี้ผ่านทางตัวสร้าง destructors และตัวดำเนินการมากเกินไป malloc/ freeเท่านั้นที่เคยจัดสรรและเพิ่มหน่วยความจำ

ในความเป็นจริงnewสามารถปรับแต่งได้อย่างเพียงพอซึ่งไม่จำเป็นต้องส่งคืนหน่วยความจำจากฮีปหรือแม้แต่จัดสรรหน่วยความจำเลย อย่างไรก็ตามค่าเริ่มต้นnewไม่

ความแตกต่างที่สำคัญระหว่าง new และ malloc ก็คือ new จะเรียกใช้ตัวสร้างของวัตถุและการเรียกที่สอดคล้องกันเพื่อลบ invokes destructor ของวัตถุ

มีความแตกต่างอื่น ๆ :

• newเป็นประเภทที่ปลอดภัยmallocส่งกลับวัตถุประเภทvoid*

• newโยนข้อยกเว้นในข้อผิดพลาดmallocผลตอบแทนNULLและการตั้งค่า errno

• newเป็นโอเปอเรเตอร์และสามารถโอเวอร์โหลดmallocได้เป็นฟังก์ชั่นและไม่สามารถโอเวอร์โหลดได้

• new[]ซึ่งจัดสรรอาเรย์นั้นง่ายกว่าและปลอดภัยกว่าประเภทอื่น ๆ malloc

• malloc- การปันส่วนที่ได้รับมาสามารถปรับขนาดผ่านrealloc- การnewปันส่วนที่ได้รับไม่สามารถปรับขนาดได้

• mallocสามารถจัดสรรหน่วยความจำแบบ N-byte ได้, newต้องทำการจัดสรรอาเรย์, charประเภท, ประเภท

เมื่อดูที่ความแตกต่างสรุปคือ malloc คือ C-esque ใหม่คือ C ++ - esque ใช้อันที่เหมาะกับฐานรหัสของคุณ

แม้ว่ามันจะถูกกฎหมายสำหรับใหม่และ malloc ที่จะดำเนินการโดยใช้อัลกอริทึมการจัดสรรหน่วยความจำที่แตกต่างกันในระบบใหม่ส่วนใหญ่จะดำเนินการภายในโดยใช้ malloc ทำให้ไม่มีความแตกต่างในระดับระบบ

มีบางสิ่งที่newทำmallocไม่ได้:

1. new สร้างวัตถุโดยการเรียกตัวสร้างของวัตถุนั้น
2. new ไม่จำเป็นต้องพิมพ์หน่วยความจำที่จัดสรร
3. ไม่จำเป็นต้องจัดสรรจำนวนหน่วยความจำ แต่ต้องการจำนวนวัตถุที่จะสร้าง

ดังนั้นถ้าคุณใช้mallocคุณต้องทำสิ่งต่าง ๆ อย่างชัดเจนซึ่งไม่สามารถนำไปใช้ได้จริงเสมอไป นอกจากนี้newสามารถโอเวอร์โหลดได้ แต่mallocไม่สามารถ

ในคำถ้าคุณใช้ C ++ ลองใช้newให้มากที่สุด

นอกจากนี้ยังมี

ใหม่ทั่วโลกและลบสามารถแทนที่, malloc / ฟรีไม่สามารถ

เพิ่มเติมใหม่และลบสามารถแทนที่ต่อประเภท

newและdeleteเป็น C + + แบบดั้งเดิมซึ่งประกาศอินสแตนซ์ใหม่ของคลาสหรือลบมัน (เช่นการเรียกใช้ destructor ของคลาสสำหรับอินสแตนซ์)

mallocและfreeเป็นฟังก์ชั่น C และจะจัดสรรและเพิ่มบล็อกหน่วยความจำ (ขนาด)

ทั้งสองใช้ฮีปเพื่อทำการจัดสรร mallocและfreeยังคง "ระดับต่ำ" มากขึ้นตามที่พวกเขาเพียงแค่สำรองพื้นที่หน่วยความจำซึ่งอาจจะเกี่ยวข้องกับตัวชี้ ไม่มีโครงสร้างใดถูกสร้างขึ้นรอบ ๆ หน่วยความจำนั้น (เว้นแต่คุณจะถือว่าอาร์เรย์ C เป็นโครงสร้าง)

ใหม่และลบเป็นตัวดำเนินการใน c ++; ซึ่งสามารถโอเวอร์โหลดได้เช่นกัน malloc และ free เป็นฟังก์ชันใน c;

malloc ส่งคืน null ptr เมื่อล้มเหลวในขณะที่มีข้อผิดพลาดเกิดขึ้นใหม่

ที่อยู่ที่ถูกส่งกลับโดย malloc ต้องตามประเภท casted อีกครั้งเนื่องจากส่งคืน (void *) malloc (ขนาด) ใหม่ส่งคืนตัวชี้ที่พิมพ์

• ใหม่เป็นผู้ประกอบการในขณะที่ malloc () เป็น fucntion
• ใหม่ส่งคืนชนิดข้อมูลที่แน่นอนในขณะที่ malloc () จะคืนค่าเป็นโมฆะ * (ตัวชี้ประเภทเป็นโมฆะ)
• malloc () หน่วยความจำไม่ได้เริ่มต้นและค่าเริ่มต้นเป็นขยะในขณะที่ในกรณีของใหม่หน่วยความจำจะเริ่มต้นด้วยค่าเริ่มต้นเช่นกับ 'ศูนย์ (0)' ในกรณีที่ int
• ลบและฟรี () ทั้งสองสามารถใช้สำหรับตัวชี้ 'NULL'

• เมื่อต้องการใช้malloc()เราต้องรวม <stdlib.h>หรือ ในโปรแกรมที่ไม่จำเป็นสำหรับ<alloc.h>new
• newและdeleteสามารถโอเวอร์โหลดได้ แต่mallocไม่สามารถทำได้
• การใช้ตำแหน่งnewที่เราสามารถส่งอยู่ที่เราต้องการที่จะจัดสรรหน่วยความจำ mallocแต่เรื่องนี้เป็นไปไม่ได้ในกรณีของ

รหัสนี้ใช้สำหรับลบคำสำคัญหรือฟังก์ชั่นฟรี แต่เมื่อสร้างวัตถุตัวชี้โดยใช้ 'malloc' หรือ 'ใหม่' และ deallocate หน่วยความจำวัตถุโดยใช้การลบแม้ตัวชี้วัตถุที่สามารถเรียกใช้ฟังก์ชั่นในชั้นเรียน หลังจากนั้นใช้ฟรีแทนการลบแล้วมันยังทำงานหลังจากคำสั่งฟรี แต่เมื่อใช้ทั้งสองแล้ววัตถุตัวชี้เท่านั้นที่ไม่สามารถเรียกใช้ฟังก์ชั่นในระดับ .. รหัสมีดังนี้:

#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

1. syntex ใหม่นั้นง่ายกว่า malloc ()

2.new/delete เป็นโอเปอเรเตอร์ที่ malloc () / free () เป็นฟังก์ชั่น

3.new/delete รันเร็วกว่า malloc () / free () เนื่องจากโค้ด assemly ใหม่วางโดยตรงโดยคอมไพเลอร์

4. เราสามารถเปลี่ยนใหม่ / ลบความหมายในโปรแกรมด้วยความช่วยเหลือของผู้ประกอบการที่ทับซ้อนกัน