วิธีการทำงานกับการจัดสรรหน่วยความจำแบบไดนามิก C ++

การจัดสรรหน่วยความจำแบบไดนามิกใน C ++ เป็นคุณสมบัติที่สำคัญมากที่ช่วยให้คุณพิจารณาความต้องการของคุณเพื่อจัดการกับความต้องการทรัพยากรแบบเรียลไทม์ ในบทความนี้เราจะสำรวจ การสำรวจโดยละเอียด คำแนะนำต่อไปนี้จะกล่าวถึงในบทความนี้

• ต้องการการจัดสรรหน่วยความจำแบบไดนามิกหรือไม่?
• การจัดสรรหน่วยความจำโดยใช้ ใหม่ คำสำคัญ
• การจัดสรรหน่วยความจำโดยใช้ ลบ คำสำคัญ
• การจัดสรรอาร์เรย์แบบไดนามิก
• การจัดสรรหน่วยความจำแบบไดนามิกสำหรับออบเจ็กต์

ดังนั้นให้เราเริ่มต้นด้วยบทความนี้เกี่ยวกับการจัดสรรหน่วยความจำแบบไดนามิกใน C ++

ต้องการการจัดสรรหน่วยความจำแบบไดนามิกหรือไม่?

สมมติว่าเราต้องการป้อนประโยคเป็นอาร์เรย์ของอักขระ แต่เราไม่แน่ใจเกี่ยวกับจำนวนอักขระที่ต้องการในอาร์เรย์

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

ในกรณีข้างต้นเราไม่มีความคิดเกี่ยวกับขนาดที่แน่นอนของอาร์เรย์จนกว่าจะถึงเวลาคอมไพล์ (เมื่อคอมพิวเตอร์รวบรวมโค้ดและผู้ใช้ป้อนสตริง) ในกรณีเช่นนี้เราใช้ไฟล์ ใหม่ ตัวดำเนินการ

C ++ กำหนดตัวดำเนินการยูนารีสองตัว ใหม่ และ ลบ ที่ทำหน้าที่จัดสรรและยกเลิกการจัดสรรหน่วยความจำระหว่างรันไทม์ เนื่องจากตัวดำเนินการเหล่านี้ (ใหม่และลบ) ทำงานบนหน่วยความจำที่จัดเก็บฟรี (หน่วยความจำฮีป) จึงเรียกอีกอย่างว่าตัวดำเนินการจัดเก็บฟรี พอยน์เตอร์ให้การสนับสนุนที่จำเป็นสำหรับระบบการจัดสรรหน่วยความจำแบบไดนามิกใน C ++

ด้วยความช่วยเหลือของ Dynamic Allocation โปรแกรมสามารถรับหน่วยความจำระหว่างรันไทม์

ฟังก์ชันใน sql คืออะไร

ตัวแปรโกลบอลและโลคัลจะถูกจัดสรรให้กับหน่วยความจำระหว่างเวลาคอมไพล์ อย่างไรก็ตามเราไม่สามารถเพิ่มตัวแปรส่วนกลางหรือภายในระหว่างรันไทม์ได้ หากโปรแกรมจำเป็นต้องใช้หน่วยความจำในจำนวนที่แปรผันเราจะต้องจัดสรรหน่วยความจำระหว่างรันไทม์ตามและเมื่อจำเป็น และแน่นอนที่นี่รูทีนการจัดสรรแบบไดนามิกสามารถตอบสนองวัตถุประสงค์ได้

ความแตกต่างระหว่างการจัดสรรหน่วยความจำแบบคงที่และการจัดสรรหน่วยความจำแบบไดนามิก:

นี่คือสถาปัตยกรรมหน่วยความจำพื้นฐานที่ใช้สำหรับโปรแกรม C ++:

เราจะต้องมีภาพเช่นนี้

สแต็กใช้สำหรับการจัดสรรหน่วยความจำแบบคงที่และฮีปสำหรับการจัดสรรหน่วยความจำแบบไดนามิกทั้งสองอย่างจะถูกเก็บไว้ใน RAM ของคอมพิวเตอร์

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

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

ไปต่อกับบทความนี้เกี่ยวกับการจัดสรรหน่วยความจำแบบไดนามิกใน C ++

การจัดสรรหน่วยความจำโดยใช้ ใหม่ คำสำคัญ

ใน C ++ ไฟล์ ใหม่ ตัวดำเนินการถูกใช้เพื่อจัดสรรหน่วยความจำที่รันไทม์และหน่วยความจำถูกจัดสรรเป็นไบต์ ใหม่ ตัวดำเนินการหมายถึงคำร้องขอสำหรับการจัดสรรหน่วยความจำแบบไดนามิกบน Heap หากมีหน่วยความจำเพียงพอแล้วไฟล์ ใหม่ ตัวดำเนินการเริ่มต้นหน่วยความจำและส่งคืนที่อยู่ของหน่วยความจำที่จัดสรรใหม่และเริ่มต้นให้กับตัวแปรพอยน์เตอร์

ไวยากรณ์:

ประเภทข้อมูล * pointer_name = ประเภทข้อมูลใหม่

ตัวอย่าง:

int * ptr = new int // เราสามารถประกาศตัวแปรในขณะที่การจัดสรรแบบไดนามิกได้สองวิธีต่อไปนี้ int * ptr = new int (10) int * ptr = new int {15} // ตัวดำเนินการใหม่ยังใช้เพื่อจัดสรรบล็อก (อาร์เรย์) ของหน่วยความจำประเภท data-type int * ptr = new int [20] // คำสั่งข้างต้นจัดสรรหน่วยความจำแบบไดนามิกสำหรับจำนวนเต็ม 20 จำนวนอย่างต่อเนื่องประเภท int และส่งกลับตัวชี้ไปยังองค์ประกอบแรกของลำดับเป็นตัวชี้ 'ptr'

บันทึก : หากฮีปมีหน่วยความจำไม่เพียงพอที่จะจัดสรรคำขอใหม่จะบ่งชี้ความล้มเหลวโดยการโยนข้อยกเว้น std :: bad_alloc เว้นแต่จะใช้ 'nothrow' กับตัวดำเนินการใหม่ซึ่งในกรณีนี้จะส่งกลับตัวชี้ NULL ดังนั้นจึงเป็นแนวทางปฏิบัติที่ดีในการตรวจสอบตัวแปรพอยน์เตอร์ที่สร้างโดย new ก่อนที่จะใช้ในโปรแกรม

ไปต่อกับบทความนี้เกี่ยวกับการจัดสรรหน่วยความจำแบบไดนามิกใน C ++

การจัดสรรหน่วยความจำโดยใช้ ลบ คำสำคัญ:

เมื่อหน่วยความจำฮีปถูกจัดสรรให้กับตัวแปรหรือคลาสออบเจ็กต์โดยใช้ ใหม่ คำหลักเราสามารถยกเลิกการจัดสรรพื้นที่หน่วยความจำนั้นโดยใช้ไฟล์ ลบ คำสำคัญ.

ไวยากรณ์:

ลบ pointer_variable // ที่นี่ pointer_variable คือตัวชี้ที่ชี้ไปยังวัตถุข้อมูลที่สร้างโดย new ลบ [] pointer_variable // เพื่อปลดปล่อยหน่วยความจำอาร์เรย์ที่จัดสรรแบบไดนามิกที่ชี้โดยตัวแปรตัวชี้เราใช้รูปแบบการลบต่อไปนี้:

ตัวอย่าง:

ลบ ptr ลบ [] ptr

บันทึก : ขอบเขตของวัตถุหรืออายุการใช้งานของวัตถุคือเวลาที่วัตถุยังคงอยู่ในหน่วยความจำระหว่างการทำงานของโปรแกรม การจัดสรรหน่วยความจำฮีปช้ากว่าสแต็กเนื่องจากในฮีปไม่มีลำดับเฉพาะที่คุณสามารถจัดสรรหน่วยความจำได้ในขณะที่สแต็กจะเป็นไปตาม LIFO

ไปต่อกับบทความนี้เกี่ยวกับการจัดสรรหน่วยความจำแบบไดนามิกใน C ++

การจัดสรรอาร์เรย์แบบไดนามิก

การใช้แนวคิดหลักของการจัดสรรหน่วยความจำแบบไดนามิกคือการจัดสรรหน่วยความจำให้กับอาร์เรย์เมื่อเราต้องประกาศโดยระบุขนาด แต่ไม่แน่ใจเกี่ยวกับมัน

มาดูตัวอย่างเพื่อทำความเข้าใจการใช้งาน

#include โดยใช้ namespace std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>len int * mark = new int [len] // การจัดสรรหน่วยความจำแบบไดนามิก cout<< 'Enter the marks of each student' << endl for( int i = 0 i>* (mark + i)} สำหรับ (int i = 0 i
 คำอธิบาย:  
ในตัวอย่างนี้ก่อนอื่นเราขอให้ผู้ใช้ระบุจำนวนนักเรียนในชั้นเรียนและเราเก็บค่าไว้ในตัวแปร len จากนั้นเราจะประกาศอาร์เรย์ของจำนวนเต็มและจัดสรรพื้นที่ในหน่วยความจำแบบไดนามิกเท่ากับค่าที่เก็บไว้ในตัวแปร len โดยใช้คำสั่งนี้ int * mark = new int [length] ดังนั้นจึงได้รับการจัดสรรพื้นที่เท่ากับ 'length * (ขนาด 1 จำนวนเต็ม)'. ส่วนที่เหลือของรหัสเป็นแบบอธิบายตนเอง
ไปต่อกับบทความนี้เกี่ยวกับการจัดสรรหน่วยความจำแบบไดนามิกใน C ++
 การจัดสรรหน่วยความจำแบบไดนามิกสำหรับออบเจ็กต์ 
นอกจากนี้เรายังสามารถจัดสรรวัตถุแบบไดนามิก
ดังที่เราทราบว่า Constructor เป็นฟังก์ชันสมาชิกคลาสพิเศษที่ใช้ในการเริ่มต้นอ็อบเจ็กต์และ Destructor ยังเป็นฟังก์ชันสมาชิกคลาสซึ่งถูกเรียกใช้เมื่อใดก็ตามที่อ็อบเจ็กต์อยู่นอกขอบเขต
สามารถใช้ Destructor เพื่อปลดปล่อยหน่วยความจำที่กำหนดให้กับวัตถุ เรียกว่าอยู่ในเงื่อนไขต่อไปนี้
เมื่อวัตถุในพื้นที่อยู่นอกขอบเขต
สำหรับวัตถุส่วนกลางเมื่อตัวดำเนินการถูกนำไปใช้กับตัวชี้ไปยังวัตถุของคลาส
เราสามารถใช้พอยน์เตอร์ได้อีกครั้งในขณะที่จัดสรรหน่วยความจำให้กับอ็อบเจ็กต์แบบไดนามิก
มาดูตัวอย่างอาร์เรย์ของวัตถุ
#include ใช้เนมสเปซคลาส std Random {public: Random () {cout<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } 
 เอาท์พุต: 
 คำอธิบาย: 
Constructor จะถูกเรียกสามครั้งเนื่องจากเราจัดสรรหน่วยความจำให้กับวัตถุสามชิ้นของคลาส Random นอกจากนี้ Destructor จะถูกเรียกสามครั้งในแต่ละวัตถุเหล่านี้ ‘Random * a = new Random [3]’ คำสั่งนี้รับผิดชอบต่อการจัดสรรหน่วยความจำแบบไดนามิกของวัตถุของเรา
ดังนั้นเราจึงมาถึงตอนท้ายของบทความนี้เกี่ยวกับ 'Dynamic Memory Allocation C ++' หากคุณต้องการเรียนรู้เพิ่มเติมโปรดดูไฟล์   โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ หลักสูตรการฝึกอบรมและการรับรอง Java J2EE และ SOA ของ Edureka ได้รับการออกแบบมาเพื่อฝึกอบรมคุณสำหรับแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับกรอบงาน Java ต่างๆเช่น Hibernate & Spring
 มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบล็อกนี้และเราจะติดต่อกลับโดยเร็วที่สุด 
c ++ fibonacci ซีรีส์