TechCodeview

גם ה malloc() וחדש ב-C++ משמשים לאותה מטרה. הם משמשים להקצאת זיכרון בזמן הריצה. אבל, ל-malloc() ול-new יש תחביר שונה. ההבדל העיקרי בין malloc() ל-new הוא שה-new הוא אופרטור בעוד malloc() היא פונקציית ספרייה סטנדרטית המוגדרת מראש ב- stdlib קובץ הכותרת.

מה חדש?

החדש הוא אופרטור הקצאת זיכרון, המשמש להקצאת הזיכרון בזמן הריצה. הזיכרון שאותחל על ידי המפעיל החדש מוקצה בערימה. הוא מחזיר את כתובת ההתחלה של הזיכרון, אשר מוקצה למשתנה. הפונקציונליות של האופרטור החדש ב-C++ דומה לפונקציה malloc() שהייתה בשימוש ב- שפת תכנות C . C++ תואם גם לפונקציה malloc() אבל האופרטור החדש משמש בעיקר בגלל היתרונות שלו.

תחביר של אופרטור חדש

 type variable = new type(parameter_list); 

בתחביר לעיל

סוּג: הוא מגדיר את סוג הנתונים של המשתנה שעבורו מוקצה הזיכרון על ידי האופרטור החדש.

מִשְׁתַנֶה: זה השם של המשתנה שמצביע על הזיכרון.

parameter_list: זוהי רשימת הערכים שמאוחלים למשתנה.

האופרטור החדש אינו משתמש באופרטור sizeof() כדי להקצות את הזיכרון. זה גם לא משתמש בשינוי הגודל שכן האופרטור החדש מקצה מספיק זיכרון לאובייקט. זהו מבנה שקורא לבנאי בזמן ההכרזה לאתחל אובייקט.

כפי שאנו יודעים שהמפעיל החדש מקצה את הזיכרון בערימה; אם הזיכרון אינו זמין בערימה והמפעיל החדש מנסה להקצות את הזיכרון, החריג נזרק. אם הקוד שלנו לא מסוגל להתמודד עם החריגה, התוכנית תסתיים באופן חריג.

בואו נבין את המפעיל החדש באמצעות דוגמה.

פולימורפיזם בג'אווה

 #include using namespace std; int main() { int *ptr; // integer pointer variable declaration ptr=new int; // allocating memory to the pointer variable ptr. std::cout &lt;&lt; &apos;Enter the number : &apos; &lt;&gt;*ptr; std::cout &lt;&lt; &apos;Entered number is &apos; &lt;<*ptr<< std::endl; return 0; } < pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/80/malloc-vs-new-c.webp" alt="malloc() vs new in C++"> <h3>What is malloc()?</h3> <p>A malloc() is a function that allocates memory at the runtime. This function returns the void pointer, which means that it can be assigned to any pointer type. This void pointer can be further typecast to get the pointer that points to the memory of a specified type.</p> <p>The syntax of the malloc() function is given below:</p> <pre> type variable_name = (type *)malloc(sizeof(type)); </pre> <p> <strong>where,</strong> </p> <p> <strong>type:</strong> it is the datatype of the variable for which the memory has to be allocated.</p> <p> <strong>variable_name:</strong> It defines the name of the variable that points to the memory.</p> <p> <strong>(type*):</strong> It is used for typecasting so that we can get the pointer of a specified type that points to the memory.</p> <p> <strong>sizeof():</strong> The sizeof() operator is used in the malloc() function to obtain the memory size required for the allocation.</p> <h4>Note: The malloc() function returns the void pointer, so typecasting is required to assign a different type to the pointer. The sizeof() operator is required in the malloc() function as the malloc() function returns the raw memory, so the sizeof() operator will tell the malloc() function how much memory is required for the allocation.</h4> <p>If the sufficient memory is not available, then the memory can be resized using realloc() function. As we know that all the dynamic memory requirements are fulfilled using heap memory, so malloc() function also allocates the memory in a heap and returns the pointer to it. The heap memory is very limited, so when our code starts execution, it marks the memory in use, and when our code completes its task, then it frees the memory by using the free() function. If the sufficient memory is not available, and our code tries to access the memory, then the malloc() function returns the NULL pointer. The memory which is allocated by the malloc() function can be deallocated by using the free() function.</p> <p> <strong>Let&apos;s understand through an example.</strong> </p> <pre> #include #include using namespace std; int main() { int len; // variable declaration std::cout &lt;&lt; &apos;Enter the count of numbers :&apos; &lt;&gt; len; int *ptr; // pointer variable declaration ptr=(int*) malloc(sizeof(int)*len); // allocating memory to the poiner variable for(int i=0;i<len;i++) { std::cout << 'enter a number : ' <> *(ptr+i); } std::cout &lt;&lt; &apos;Entered elements are : &apos; &lt;&lt; std::endl; for(int i=0;i<len;i++) { std::cout << *(ptr+i) std::endl; } free(ptr); return 0; < pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/80/malloc-vs-new-c-2.webp" alt="malloc() vs new in C++"> <p>If we do not use the <strong>free()</strong> function at the correct place, then it can lead to the cause of the dangling pointer. <strong>Let&apos;s understand this scenario through an example.</strong> </p> <pre> #include #include using namespace std; int *func() { int *p; p=(int*) malloc(sizeof(int)); free(p); return p; } int main() { int *ptr; ptr=func(); free(ptr); return 0; } </pre> <p>In the above code, we are calling the func() function. The func() function returns the integer pointer. Inside the func() function, we have declared a *p pointer, and the memory is allocated to this pointer variable using malloc() function. In this case, we are returning the pointer whose memory is already released. The ptr is a dangling pointer as it is pointing to the released memory location. Or we can say ptr is referring to that memory which is not pointed by the pointer.</p> <p>Till now, we get to know about the new operator and the malloc() function. Now, we will see the differences between the new operator and the malloc() function.</p> <h3>Differences between the malloc() and new</h3> <img src="//techcodeview.com/img/c-tutorial/80/malloc-vs-new-c-3.webp" alt="malloc() vs new in C++"> <ul> <li>The new operator constructs an object, i.e., it calls the constructor to initialize an object while <strong>malloc()</strong> function does not call the constructor. The new operator invokes the constructor, and the delete operator invokes the destructor to destroy the object. This is the biggest difference between the malloc() and new.</li> <li>The new is an operator, while malloc() is a predefined function in the stdlib header file.</li> <li>The operator new can be overloaded while the malloc() function cannot be overloaded.</li> <li>If the sufficient memory is not available in a heap, then the new operator will throw an exception while the malloc() function returns a NULL pointer.</li> <li>In the new operator, we need to specify the number of objects to be allocated while in malloc() function, we need to specify the number of bytes to be allocated.</li> <li>In the case of a new operator, we have to use the delete operator to deallocate the memory. But in the case of malloc() function, we have to use the free() function to deallocate the memory.</li> </ul> <p> <strong>Syntax of new operator</strong> </p> <pre> type reference_variable = new type name; </pre> <p> <strong>where,</strong> </p> <p> <strong>type:</strong> It defines the data type of the reference variable.</p> <p> <strong>reference_variable:</strong> It is the name of the pointer variable.</p> <p> <strong>new:</strong> It is an operator used for allocating the memory.</p> <p> <strong>type name:</strong> It can be any basic data type.</p> <p> <strong>For example,</strong> </p> <pre> int *p; p = new int; </pre> <p>In the above statements, we are declaring an integer pointer variable. The statement <strong>p = new int;</strong> allocates the memory space for an integer variable.</p> <p> <strong>Syntax of malloc() is given below:</strong> </p> <pre> int *ptr = (data_type*) malloc(sizeof(data_type)); </pre> <p> <strong>ptr:</strong> It is a pointer variable.</p> <p> <strong>data_type:</strong> It can be any basic data type.</p> <p> <strong>For example,</strong> </p> <pre> int *p; p = (int *) malloc(sizeof(int)) </pre> <p>The above statement will allocate the memory for an integer variable in a heap, and then stores the address of the reserved memory in &apos;p&apos; variable.</p> <ul> <li>On the other hand, the memory allocated using malloc() function can be deallocated using the free() function.</li> <li>Once the memory is allocated using the new operator, then it cannot be resized. On the other hand, the memory is allocated using malloc() function; then, it can be reallocated using realloc() function.</li> <li>The execution time of new is less than the malloc() function as new is a construct, and malloc is a function.</li> <li>The new operator does not return the separate pointer variable; it returns the address of the newly created object. On the other hand, the malloc() function returns the void pointer which can be further typecast in a specified type.</li> </ul> <hr></len;i++)></len;i++)></pre></*ptr<<>

איפה,

סוּג: זהו סוג הנתונים של המשתנה שעבורו יש להקצות את הזיכרון.

שם משתנה: הוא מגדיר את שם המשתנה שמצביע על הזיכרון.

(סוּג*): הוא משמש ל-typecasting כדי שנוכל לקבל את המצביע של סוג מסוים שמצביע על הזיכרון.

מידה של(): האופרטור sizeof() משמש בפונקציה malloc() כדי לקבל את גודל הזיכרון הנדרש להקצאה.

הערה: הפונקציה malloc() מחזירה את מצביע הריק, כך ש-typecasting נדרשת כדי להקצות סוג אחר למצביע. האופרטור sizeof() נדרש בפונקציה malloc() שכן הפונקציה malloc() מחזירה את הזיכרון הגולמי, כך שהאופרטור sizeof() יגיד לפונקציה malloc() כמה זיכרון נדרש להקצאה.

אם הזיכרון המספיק אינו זמין, ניתן לשנות את גודל הזיכרון באמצעות פונקציית realloc() . מכיוון שאנו יודעים שכל דרישות הזיכרון הדינמי מתמלאות באמצעות זיכרון ערימה, כך גם הפונקציה malloc() מקצה את הזיכרון בערימה ומחזירה אליו את המצביע. זיכרון הערימה מוגבל מאוד, כך שכאשר הקוד שלנו מתחיל בביצוע, הוא מסמן את הזיכרון בשימוש, וכאשר הקוד שלנו משלים את המשימה שלו, אז הוא משחרר את הזיכרון באמצעות הפונקציה free() . אם הזיכרון המספיק אינו זמין, והקוד שלנו מנסה לגשת לזיכרון, הפונקציה malloc() מחזירה את המצביע NULL. ניתן להקצות את הזיכרון המוקצה על ידי הפונקציה malloc() באמצעות הפונקציה free() .

בואו נבין דרך דוגמה.

 #include #include using namespace std; int main() { int len; // variable declaration std::cout &lt;&lt; &apos;Enter the count of numbers :&apos; &lt;&gt; len; int *ptr; // pointer variable declaration ptr=(int*) malloc(sizeof(int)*len); // allocating memory to the poiner variable for(int i=0;i<len;i++) { std::cout << \'enter a number : \' <> *(ptr+i); } std::cout &lt;&lt; &apos;Entered elements are : &apos; &lt;&lt; std::endl; for(int i=0;i<len;i++) { std::cout << *(ptr+i) std::endl; } free(ptr); return 0; < pre> <p> <strong>Output:</strong> </p> <img src="//techcodeview.com/img/c-tutorial/80/malloc-vs-new-c-2.webp" alt="malloc() vs new in C++"> <p>If we do not use the <strong>free()</strong> function at the correct place, then it can lead to the cause of the dangling pointer. <strong>Let&apos;s understand this scenario through an example.</strong> </p> <pre> #include #include using namespace std; int *func() { int *p; p=(int*) malloc(sizeof(int)); free(p); return p; } int main() { int *ptr; ptr=func(); free(ptr); return 0; } </pre> <p>In the above code, we are calling the func() function. The func() function returns the integer pointer. Inside the func() function, we have declared a *p pointer, and the memory is allocated to this pointer variable using malloc() function. In this case, we are returning the pointer whose memory is already released. The ptr is a dangling pointer as it is pointing to the released memory location. Or we can say ptr is referring to that memory which is not pointed by the pointer.</p> <p>Till now, we get to know about the new operator and the malloc() function. Now, we will see the differences between the new operator and the malloc() function.</p> <h3>Differences between the malloc() and new</h3> <img src="//techcodeview.com/img/c-tutorial/80/malloc-vs-new-c-3.webp" alt="malloc() vs new in C++"> <ul> <li>The new operator constructs an object, i.e., it calls the constructor to initialize an object while <strong>malloc()</strong> function does not call the constructor. The new operator invokes the constructor, and the delete operator invokes the destructor to destroy the object. This is the biggest difference between the malloc() and new.</li> <li>The new is an operator, while malloc() is a predefined function in the stdlib header file.</li> <li>The operator new can be overloaded while the malloc() function cannot be overloaded.</li> <li>If the sufficient memory is not available in a heap, then the new operator will throw an exception while the malloc() function returns a NULL pointer.</li> <li>In the new operator, we need to specify the number of objects to be allocated while in malloc() function, we need to specify the number of bytes to be allocated.</li> <li>In the case of a new operator, we have to use the delete operator to deallocate the memory. But in the case of malloc() function, we have to use the free() function to deallocate the memory.</li> </ul> <p> <strong>Syntax of new operator</strong> </p> <pre> type reference_variable = new type name; </pre> <p> <strong>where,</strong> </p> <p> <strong>type:</strong> It defines the data type of the reference variable.</p> <p> <strong>reference_variable:</strong> It is the name of the pointer variable.</p> <p> <strong>new:</strong> It is an operator used for allocating the memory.</p> <p> <strong>type name:</strong> It can be any basic data type.</p> <p> <strong>For example,</strong> </p> <pre> int *p; p = new int; </pre> <p>In the above statements, we are declaring an integer pointer variable. The statement <strong>p = new int;</strong> allocates the memory space for an integer variable.</p> <p> <strong>Syntax of malloc() is given below:</strong> </p> <pre> int *ptr = (data_type*) malloc(sizeof(data_type)); </pre> <p> <strong>ptr:</strong> It is a pointer variable.</p> <p> <strong>data_type:</strong> It can be any basic data type.</p> <p> <strong>For example,</strong> </p> <pre> int *p; p = (int *) malloc(sizeof(int)) </pre> <p>The above statement will allocate the memory for an integer variable in a heap, and then stores the address of the reserved memory in &apos;p&apos; variable.</p> <ul> <li>On the other hand, the memory allocated using malloc() function can be deallocated using the free() function.</li> <li>Once the memory is allocated using the new operator, then it cannot be resized. On the other hand, the memory is allocated using malloc() function; then, it can be reallocated using realloc() function.</li> <li>The execution time of new is less than the malloc() function as new is a construct, and malloc is a function.</li> <li>The new operator does not return the separate pointer variable; it returns the address of the newly created object. On the other hand, the malloc() function returns the void pointer which can be further typecast in a specified type.</li> </ul> <hr></len;i++)></len;i++)>

בקוד לעיל, אנו קוראים לפונקציה func() . הפונקציה func() מחזירה את מצביע המספר השלם. בתוך הפונקציה func() הכרזנו על מצביע *p, והזיכרון מוקצה למשתנה המצביע הזה באמצעות הפונקציה malloc(). במקרה זה, אנו מחזירים את המצביע שהזיכרון שלו כבר שוחרר. ה-ptr הוא מצביע משתלשל כאשר הוא מצביע על מיקום הזיכרון המשוחרר. או שנוכל לומר ש-ptr מתייחס לזיכרון הזה שאינו מצביע על ידי המצביע.

עד עכשיו, אנו למדים על האופרטור החדש ועל הפונקציה malloc() . כעת, נראה את ההבדלים בין האופרטור החדש לבין הפונקציה malloc().

הבדלים בין malloc() ל-new

• האופרטור החדש בונה אובייקט, כלומר, הוא קורא לבנאי לאתחל אובייקט תוך כדי malloc() הפונקציה לא קוראת לבנאי. האופרטור החדש מפעיל את הקונסטרוקטור, ואופרטור המחיקה מפעיל את הגורם ההורס כדי להרוס את האובייקט. זהו ההבדל הגדול ביותר בין malloc() ל-new.
• החדש הוא אופרטור, בעוד malloc() היא פונקציה מוגדרת מראש בקובץ הכותרת stdlib.
• ניתן להעמיס על האופרטור new בעוד שלא ניתן להעמיס על הפונקציה malloc().
• אם הזיכרון המספיק אינו זמין בערימה, האופרטור החדש יזרוק חריג בזמן שהפונקציה malloc() מחזירה מצביע NULL.
• באופרטור החדש, עלינו לציין את מספר האובייקטים שיוקצו בעוד בפונקציה malloc() אנו צריכים לציין את מספר הבתים שיוקצו.
• במקרה של אופרטור חדש, עלינו להשתמש באופרטור המחיקה כדי להקצות את הזיכרון. אבל במקרה של פונקציית malloc(), עלינו להשתמש בפונקציה free() כדי להקצות את הזיכרון.

תחביר של אופרטור חדש

 type reference_variable = new type name; 

איפה,

סוּג: הוא מגדיר את סוג הנתונים של משתנה ההתייחסות.

reference_variable: זה השם של משתנה המצביע.

חָדָשׁ: זהו אופרטור המשמש להקצאת הזיכרון.

סוג שם: זה יכול להיות כל סוג נתונים בסיסי.

לדוגמה,

 int *p; p = new int; 

בהצהרות לעיל, אנו מצהירים על משתנה מצביע שלם. ההצהרה p = new int; מקצה את שטח הזיכרון למשתנה מספר שלם.

תחביר של malloc() ניתן להלן:

 int *ptr = (data_type*) malloc(sizeof(data_type)); 

ptr: זה משתנה מצביע.

סוג מידע: זה יכול להיות כל סוג נתונים בסיסי.

לדוגמה,

 int *p; p = (int *) malloc(sizeof(int)) 

ההצהרה לעיל תקצה את הזיכרון למשתנה מספר שלם בערימה, ולאחר מכן תשמור את הכתובת של הזיכרון השמור במשתנה 'p'.

• מצד שני, ניתן להקצות את הזיכרון המוקצה באמצעות פונקציית malloc() באמצעות הפונקציה free() .
• ברגע שהזיכרון מוקצה באמצעות האופרטור החדש, לא ניתן לשנות את גודלו. מצד שני, הזיכרון מוקצה באמצעות פונקציית malloc(); לאחר מכן, ניתן להקצות אותו מחדש באמצעות הפונקציה realloc().
• זמן הביצוע של new קטן מהפונקציה malloc() שכן new היא מבנה, ו-malloc היא פונקציה.
• האופרטור החדש אינו מחזיר את משתנה המצביע הנפרד; הוא מחזיר את הכתובת של האובייקט החדש שנוצר. מצד שני, הפונקציה malloc() מחזירה את מצביע הריק שניתן להטיל אותו בסוג מסוים.