Gan malloc () un jauni C++ tiek izmantoti tam pašam mērķim. Tos izmanto atmiņas piešķiršanai izpildlaikā. Bet malloc () un new ir atšķirīga sintakse. Galvenā atšķirība starp malloc () un new ir tā, ka jaunais ir operators, savukārt malloc () ir standarta bibliotēkas funkcija, kas ir iepriekš definēta stdlib galvenes fails.
Kas jauns?
Jaunais ir atmiņas piešķiršanas operators, ko izmanto atmiņas piešķiršanai izpildlaikā. Jaunā operatora inicializētā atmiņa tiek piešķirta kaudzē. Tas atgriež atmiņas sākuma adresi, kas tiek piešķirta mainīgajam. Jaunā operatora funkcionalitāte programmā C++ ir līdzīga funkcijai malloc(), kas tika izmantota C programmēšanas valoda . C++ ir saderīgs arī ar malloc() funkciju, taču jaunais operators galvenokārt tiek izmantots tā priekšrocību dēļ.
Jaunā operatora sintakse
type variable = new type(parameter_list);
Iepriekš minētajā sintaksē
veids: Tas nosaka mainīgā lieluma datu tipu, kuram jaunais operators piešķir atmiņu.
mainīgais: Tas ir mainīgā nosaukums, kas norāda uz atmiņu.
parametru_saraksts: Tas ir to vērtību saraksts, kuras tiek inicializētas uz mainīgo.
Jaunais operators neizmanto operatoru sizeof(), lai piešķirtu atmiņu. Tas arī neizmanto izmēru maiņu, jo jaunais operators objektam piešķir pietiekami daudz atmiņas. Tā ir konstrukcija, kas deklarēšanas laikā izsauc konstruktoru, lai inicializētu objektu.
Kā zināms, jaunais operators atmiņu piešķir kaudzē; ja atmiņa nav pieejama kaudzē un jaunais operators mēģina piešķirt atmiņu, tad tiek izmests izņēmums. Ja mūsu kods nevar apstrādāt izņēmumu, programma tiks pārtraukta neparasti.
Izpratīsim jauno operatoru, izmantojot piemēru.
#include using namespace std; int main() { int *ptr; // integer pointer variable declaration ptr=new int; // allocating memory to the pointer variable ptr. std::cout << 'Enter the number : ' <>*ptr; std::cout << 'Entered number is ' <<*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's understand through an example.</strong> </p> <pre> #include #include using namespace std; int main() { int len; // variable declaration std::cout << 'Enter the count of numbers :' <> 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 << 'Entered elements are : ' << 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'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 'p' 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<<> kur,
c++ int uz virkni
veids: tas ir mainīgā datu tips, kuram ir jāpiešķir atmiņa.
mainīgā_nosaukums: Tas nosaka mainīgā nosaukumu, kas norāda uz atmiņu.
(tips*): To izmanto tipa apraidei, lai mēs varētu iegūt noteikta tipa rādītāju, kas norāda uz atmiņu.
izmērs(): Operators sizeof() tiek izmantots funkcijā malloc(), lai iegūtu piešķiršanai nepieciešamo atmiņas apjomu.
Piezīme. Funkcija malloc() atgriež tukšuma rādītāju, tāpēc ir nepieciešama tipa apraide, lai rādītājam piešķirtu citu veidu. Operators sizeof() ir nepieciešams funkcijā malloc(), jo funkcija malloc() atgriež neapstrādāto atmiņu, tāpēc operators sizeof() norāda funkcijai malloc(), cik daudz atmiņas ir nepieciešams piešķiršanai.
Ja nav pietiekami daudz atmiņas, atmiņas lielumu var mainīt, izmantojot funkciju realloc(). Tā kā mēs zinām, ka visas dinamiskās atmiņas prasības tiek izpildītas, izmantojot kaudzes atmiņu, tāpēc funkcija malloc () arī piešķir atmiņu kaudzē un atgriež uz to rādītāju. Kaudzes atmiņa ir ļoti ierobežota, tāpēc, kad mūsu kods sāk izpildi, tas atzīmē izmantoto atmiņu, un, kad mūsu kods pabeidz savu uzdevumu, tas atbrīvo atmiņu, izmantojot funkciju free(). Ja nav pieejama pietiekama atmiņa un mūsu kods mēģina piekļūt atmiņai, funkcija malloc () atgriež NULL rādītāju. Atmiņu, ko piešķir funkcija malloc (), var atbrīvot, izmantojot funkciju free ().
Sapratīsim, izmantojot piemēru.
#include #include using namespace std; int main() { int len; // variable declaration std::cout << 'Enter the count of numbers :' <> 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 << 'Entered elements are : ' << 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'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 'p' 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++)> Iepriekš minētajā kodā mēs izsaucam funkciju func (). Funkcija func() atgriež vesela skaitļa rādītāju. Func () funkcijā mēs esam deklarējuši *p rādītāju, un atmiņa tiek piešķirta šim rādītāja mainīgajam, izmantojot funkciju malloc (). Šajā gadījumā mēs atgriežam rādītāju, kura atmiņa jau ir atbrīvota. PTR ir karājošs rādītājs, jo tas norāda uz atbrīvoto atmiņas vietu. Vai arī mēs varam teikt, ka ptr attiecas uz atmiņu, uz kuru nav norādīts rādītājs.
Līdz šim mēs uzzinājām par jauno operatoru un funkciju malloc(). Tagad mēs redzēsim atšķirības starp jauno operatoru un malloc () funkciju.
Atšķirības starp malloc () un jauno
- Jaunais operators konstruē objektu, t.i., tas aicina konstruktoru inicializēt objektu, kamēr malloc () funkcija neizsauc konstruktoru. Jaunais operators izsauc konstruktoru, un dzēšanas operators izsauc destruktoru, lai iznīcinātu objektu. Šī ir lielākā atšķirība starp malloc () un jauno.
- Jaunais ir operators, savukārt malloc () ir iepriekš definēta funkcija stdlib galvenes failā.
- Operatoru new var pārslogot, savukārt malloc() funkciju nevar pārslogot.
- Ja kaudzē nav pieejama pietiekama atmiņa, jaunais operators izliks izņēmumu, kamēr funkcija malloc () atgriež NULL rādītāju.
- Jaunajā operatorā mums ir jānorāda piešķiramo objektu skaits, savukārt funkcijā malloc () mums ir jānorāda piešķiramo baitu skaits.
- Jauna operatora gadījumā mums ir jāizmanto dzēšanas operators, lai atbrīvotu atmiņu. Bet funkcijas malloc () gadījumā mums ir jāizmanto funkcija free (), lai atbrīvotu atmiņu.
Jaunā operatora sintakse
type reference_variable = new type name;
kur,
veids: Tas nosaka atsauces mainīgā datu tipu.
reference_variable: Tas ir rādītāja mainīgā nosaukums.
jauns: Tas ir operators, ko izmanto atmiņas piešķiršanai.
tipa nosaukums: Tas var būt jebkurš pamatdatu tips.
Piemēram,
int *p; p = new int;
Iepriekš minētajos paziņojumos mēs deklarējam veselu rādītāju mainīgo. Paziņojums p = jauns int; piešķir atmiņas vietu veselam mainīgajam.
Malloc () sintakse ir norādīta zemāk:
int *ptr = (data_type*) malloc(sizeof(data_type));
ptr: Tas ir rādītāja mainīgais.
datu tips: Tas var būt jebkurš pamatdatu tips.
Piemēram,
int *p; p = (int *) malloc(sizeof(int))
Iepriekš minētais paziņojums piešķirs atmiņu veselam skaitļa mainīgajam kaudzē un pēc tam saglabās rezervētās atmiņas adresi mainīgajā “p”.
kādi ir mana datora ekrāna izmēri
- No otras puses, atmiņu, kas piešķirta, izmantojot funkciju malloc (), var noņemt, izmantojot funkciju free ().
- Kad atmiņa ir piešķirta, izmantojot jauno operatoru, tās izmērus nevar mainīt. No otras puses, atmiņa tiek piešķirta, izmantojot funkciju malloc(); tad to var pārdalīt, izmantojot funkciju realloc ().
- Jaunās izpildes laiks ir mazāks par malloc() funkciju, jo new ir konstrukcija, bet malloc ir funkcija.
- Jaunais operators neatgriež atsevišķu rādītāja mainīgo; tas atgriež jaunizveidotā objekta adresi. No otras puses, funkcija malloc () atgriež tukšuma rādītāju, kuru var tālāk ievadīt noteiktā veidā.