ความแตกต่างระหว่าง malloc () และ calloc ()
ความแตกต่างที่สำคัญระหว่าง malloc() กับ calloc()
- ฟังก์ชัน malloc() ส่งคืนเฉพาะที่อยู่เริ่มต้นและไม่ได้ทำให้เป็นศูนย์ ในทางกลับกัน ฟังก์ชัน calloc() จะส่งคืนที่อยู่เริ่มต้นและทำให้เป็นศูนย์
- ในฟังก์ชัน malloc จำนวนอาร์กิวเมนต์คือ 1 ในขณะที่ฟังก์ชัน calloc จำนวนอาร์กิวเมนต์คือ 2
- ประสิทธิภาพเวลาของ malloc() สูงกว่า calloc() ในขณะที่ malloc() ไม่ปลอดภัยเมื่อเทียบกับ calloc()
- malloc ไม่ได้เตรียมใช้งานหน่วยความจำ ในขณะที่ calloc ดำเนินการเตรียมใช้งานหน่วยความจำ

การจัดสรรหน่วยความจำแบบไดนามิกคืออะไร?
การจัดสรรหน่วยความจำแบบไดนามิก เป็นกระบวนการจัดสรรหน่วยความจำ ณ รันไทม์ มีไลบรารีรูทีนอยู่สี่รูทีนคือ calloc(), free() เรียลล็อค()และ malloc() ซึ่งสามารถใช้เพื่อจัดสรรหน่วยความจำและเพิ่มพื้นที่ว่างระหว่างการทำงานของโปรแกรม รูทีนเหล่านี้ถูกกำหนดไว้ในไฟล์ส่วนหัวชื่อ stdlib.h
malloc() คืออะไร?
เป็นฟังก์ชันที่ใช้ในการจัดสรรบล็อกหน่วยความจำแบบไดนามิก จะสงวนพื้นที่หน่วยความจำตามขนาดที่ระบุและส่งกลับตัวชี้ null ที่ชี้ไปยังตำแหน่งหน่วยความจำ
ตัวชี้ที่ส่งคืนมักจะเป็นประเภทโมฆะ หมายความว่าเราสามารถกำหนดฟังก์ชัน malloc ให้กับพอยน์เตอร์ใดก็ได้ malloc รูปแบบเต็มคือการจัดสรรหน่วยความจำ
calloc() คืออะไร?
ฟังก์ชัน Calloc() ใช้เพื่อจัดสรรหน่วยความจำหลายบล็อก เป็นฟังก์ชันการจัดสรรหน่วยความจำแบบไดนามิกซึ่งใช้เพื่อจัดสรรหน่วยความจำให้กับโครงสร้างข้อมูลที่ซับซ้อน เช่น อาร์เรย์และโครงสร้าง หากฟังก์ชันนี้จัดสรรพื้นที่ได้ไม่เพียงพอตามที่ระบุ ฟังก์ชันจะส่งกลับตัวชี้ null รูปแบบเต็มของฟังก์ชัน calloc คือการจัดสรรแบบต่อเนื่อง
ความแตกต่างระหว่าง malloc() และ calloc()
นี่คือข้อแตกต่างที่สำคัญระหว่าง malloc() กับ calloc():
มัลลอค () | การโทร () |
---|---|
ฟังก์ชัน Malloc() จะสร้างบล็อกหน่วยความจำขนาดเดียวที่ผู้ใช้ระบุ | ฟังก์ชัน Calloc() สามารถกำหนดหน่วยความจำหลายบล็อกให้กับตัวแปรได้ |
ฟังก์ชัน Malloc มีค่าขยะ | บล็อกหน่วยความจำที่จัดสรรโดยฟังก์ชัน calloc จะถูกเตรียมใช้งานให้เป็นศูนย์เสมอ |
จำนวนอาร์กิวเมนต์คือ 1 | จำนวนอาร์กิวเมนต์คือ 2 |
Calloc ช้ากว่า malloc | Malloc เร็วกว่า calloc |
มันไม่ปลอดภัยเมื่อเปรียบเทียบกับ calloc | มีความปลอดภัยในการใช้งานเมื่อเทียบกับ malloc |
ประสิทธิภาพด้านเวลาสูงกว่า calloc() | ประสิทธิภาพด้านเวลาต่ำกว่า malloc() |
ฟังก์ชัน Malloc() ส่งคืนเฉพาะที่อยู่เริ่มต้นและไม่ทำให้เป็นศูนย์ | ก่อนที่จะจัดสรรที่อยู่ ฟังก์ชัน Calloc() จะส่งคืนที่อยู่เริ่มต้นและทำให้เป็นศูนย์ |
มันไม่ได้ดำเนินการเริ่มต้นหน่วยความจำ | มันดำเนินการเริ่มต้นหน่วยความจำ |
ไวยากรณ์ของ malloc()
นี่คือไวยากรณ์ของ malloc()
ptr = (cast_type *) malloc (byte_size);
ในไวยากรณ์ข้างต้น ptr เป็นตัวชี้ของ cast_type ฟังก์ชัน malloc ส่งคืนตัวชี้ไปยังหน่วยความจำที่จัดสรรเป็น byte_size
Example: ptr = (int *) malloc (50)
เมื่อดำเนินการคำสั่งนี้สำเร็จ พื้นที่หน่วยความจำ 50 ไบต์จะถูกสงวนไว้ ที่อยู่ของไบต์แรกของพื้นที่สงวนถูกกำหนดให้กับตัวชี้ "ptr" ประเภท int
ไวยากรณ์ของ calloc()
นี่คือไวยากรณ์ของ malloc()
ptr = (cast_type *) calloc (n, size);
ไวยากรณ์ด้านบนใช้เพื่อจัดสรรบล็อกหน่วยความจำที่มีขนาดเท่ากัน หลังจากที่จัดสรรพื้นที่หน่วยความจำแล้ว ไบต์ทั้งหมดจะถูกเตรียมใช้งานให้เป็นศูนย์ ตัวชี้ซึ่งขณะนี้อยู่ที่ไบต์แรกของพื้นที่หน่วยความจำที่จัดสรรจะถูกส่งกลับ
ตัวอย่างของ malloc() ในภาษา C
ในโค้ดต่อไปนี้ sizeof(*ptr) ใช้เพื่อจัดสรรบล็อกหน่วยความจำจำนวนเต็ม 15 จำนวน ในคำสั่ง printf เรากำลังค้นหาค่าของจำนวนเต็มตัวที่ 6
#include<stdlib.h> #include<stdio.h> int main(){ int *ptr; ptr = malloc(15 * sizeof(*ptr)); if (ptr != NULL) { *(ptr + 5) = 480; printf("Value of the 6th integer is %d",*(ptr + 5)); } }
Output:
ค่าของจำนวนเต็มตัวที่ 6 คือ 480
ตัวอย่างของ calloc() ในภาษา C
โปรแกรมภาษา C ด้านล่างนี้คำนวณผลรวมของคำศัพท์สิบคำแรก หากค่าตัวชี้เป็นโมฆะ พื้นที่หน่วยความจำจะไม่ได้รับการจัดสรร
For loop ใช้เพื่อวนซ้ำค่าของตัวแปร “i” และพิมพ์ผลรวม สุดท้ายนี้ ฟังก์ชั่นฟรี ใช้เพื่อปล่อยตัวชี้ให้ว่าง
#include <stdio.h> #include <stdlib.h> int main() { int i, * ptr, sum = 0; ptr = calloc(10, sizeof(int)); if (ptr == NULL) { printf("Error! memory not allocated."); exit(0); } printf("Building and calculating the sequence sum of the first 10 terms \n"); for (i = 0; i < 10; ++i) { * (ptr + i) = i; sum += * (ptr + i); } printf("Sum = %d", sum); free(ptr); return 0; }
Output:
การสร้างและคำนวณผลรวมลำดับของ 10 เทอมแรก n รวม = 45
ทำไมต้องใช้ malloc() ?
นี่คือเหตุผลของการใช้ malloc()
- คุณควรใช้ malloc() เมื่อคุณต้องจัดสรรหน่วยความจำขณะรันไทม์
- คุณควรใช้ malloc เมื่อคุณต้องการจัดสรรอ็อบเจ็กต์ซึ่งต้องมีอยู่นอกเหนือการดำเนินการของบล็อกหน่วยความจำปัจจุบัน
- เลือกใช้ malloc() หากคุณต้องการจัดสรรหน่วยความจำที่มากกว่าขนาดของสแต็กนั้น
- มันจะคืนค่าตัวชี้ไปที่ไบต์แรกของพื้นที่ที่จัดสรร
- ช่วยให้นักพัฒนาสามารถจัดสรรหน่วยความจำได้ตามต้องการในปริมาณที่แน่นอน
- ฟังก์ชันนี้จัดสรรขนาดบล็อกหน่วยความจำเป็นไบต์จากฮีป
ทำไมต้องใช้ calloc() ?
นี่คือเหตุผลของการใช้ calloc()
- เมื่อคุณต้องตั้งค่าหน่วยความจำที่จัดสรรให้เป็นศูนย์
- คุณสามารถใช้ calloc ที่ส่งคืนพอยน์เตอร์เพื่อเข้าถึงฮีปหน่วยความจำ
- ใช้เมื่อคุณต้องการเริ่มต้นองค์ประกอบให้เป็นศูนย์เพื่อส่งคืนตัวชี้ไปยังหน่วยความจำ
- เพื่อป้องกันการโอเวอร์โฟลว์ที่เป็นไปได้ด้วย malloc()
- ใช้ calloc() เพื่อขอเพจที่ทราบว่ามีค่าศูนย์อยู่แล้ว