Begge malloc() og ny i C++ brukes til samme formål. De brukes til å tildele minne under kjøretiden. Men malloc() og new har forskjellig syntaks. Hovedforskjellen mellom malloc() og new er at den nye er en operatør mens malloc() er en standard bibliotekfunksjon som er forhåndsdefinert i en stdlib header-fil.
Hva er nytt?
Det nye er en minneallokeringsoperatør, som brukes til å tildele minnet under kjøretiden. Minnet initialisert av den nye operatøren tildeles i en haug. Den returnerer startadressen til minnet, som blir tildelt variabelen. Funksjonaliteten til den nye operatøren i C++ ligner malloc()-funksjonen, som ble brukt i C programmeringsspråk . C++ er også kompatibel med malloc()-funksjonen, men den nye operatoren brukes mest på grunn av fordelene.
nettverk og internett
Syntaks for ny operatør
type variable = new type(parameter_list);
I syntaksen ovenfor
type: Den definerer datatypen til variabelen som minnet er tildelt av den nye operatøren.
variabel: Det er navnet på variabelen som peker til minnet.
parameter_list: Det er listen over verdier som initialiseres til en variabel.
Den nye operatoren bruker ikke sizeof()-operatoren for å tildele minnet. Den bruker heller ikke endre størrelsen da den nye operatøren tildeler tilstrekkelig minne for et objekt. Det er en konstruksjon som kaller konstruktøren på tidspunktet for erklæringen for å initialisere et objekt.
Som vi vet at den nye operatøren allokerer minnet i en haug; hvis minnet ikke er tilgjengelig i en haug og den nye operatøren prøver å tildele minnet, blir unntaket kastet. Hvis koden vår ikke er i stand til å håndtere unntaket, vil programmet avsluttes unormalt.
La oss forstå den nye operatøren gjennom et eksempel.
#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<<> hvor,
type: det er datatypen til variabelen som minnet må tildeles for.
variabelnavn: Den definerer navnet på variabelen som peker til minnet.
c# inneholder streng
(type*): Den brukes til typecasting slik at vi kan få pekeren til en spesifisert type som peker til minnet.
størrelsen av(): Sizeof()-operatoren brukes i malloc()-funksjonen for å få minnestørrelsen som kreves for allokeringen.
Merk: Malloc()-funksjonen returnerer void-pekeren, så typecasting er nødvendig for å tilordne en annen type til pekeren. Sizeof()-operatoren kreves i malloc()-funksjonen ettersom malloc()-funksjonen returnerer råminnet, så sizeof()-operatoren vil fortelle malloc()-funksjonen hvor mye minne som kreves for allokeringen.
Hvis tilstrekkelig minne ikke er tilgjengelig, kan minnet endres ved hjelp av realloc()-funksjonen. Siden vi vet at alle kravene til dynamisk minne er oppfylt ved bruk av heap-minne, så allokerer malloc()-funksjonen også minnet i en heap og returnerer pekeren til den. Heap-minnet er svært begrenset, så når koden vår begynner å kjøre, markerer den minnet som er i bruk, og når koden vår fullfører oppgaven, frigjør den minnet ved å bruke free()-funksjonen. Hvis tilstrekkelig minne ikke er tilgjengelig, og koden vår prøver å få tilgang til minnet, returnerer malloc()-funksjonen NULL-pekeren. Minnet som er allokert av malloc()-funksjonen kan deallokeres ved å bruke free()-funksjonen.
La oss forstå gjennom et eksempel.
#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++)> I koden ovenfor kaller vi func()-funksjonen. Func()-funksjonen returnerer heltallspekeren. Inne i func()-funksjonen har vi erklært en *p-peker, og minnet er allokert til denne pekervariabelen ved å bruke malloc()-funksjonen. I dette tilfellet returnerer vi pekeren hvis minne allerede er frigitt. Ptr-en er en dinglende peker når den peker til det frigitte minnestedet. Eller vi kan si at ptr refererer til det minnet som ikke er pekt av pekeren.
Til nå har vi fått vite om den nye operatoren og malloc()-funksjonen. Nå vil vi se forskjellene mellom den nye operatøren og malloc()-funksjonen.
Forskjeller mellom malloc() og new
- Den nye operatøren konstruerer et objekt, det vil si at den kaller konstruktøren for å initialisere et objekt mens malloc() funksjonen kaller ikke konstruktøren. Den nye operatøren påkaller konstruktøren, og sletteoperatøren påkaller destruktoren for å ødelegge objektet. Dette er den største forskjellen mellom malloc() og new.
- Den nye er en operatør, mens malloc() er en forhåndsdefinert funksjon i stdlib-headerfilen.
- Operatøren new kan overbelastes mens malloc()-funksjonen ikke kan overbelastes.
- Hvis tilstrekkelig minne ikke er tilgjengelig i en haug, vil den nye operatøren gi et unntak mens malloc()-funksjonen returnerer en NULL-peker.
- I den nye operatoren må vi spesifisere antall objekter som skal tildeles mens i malloc()-funksjonen må vi spesifisere antall byte som skal tildeles.
- Når det gjelder en ny operatør, må vi bruke sletteoperatøren for å deallokere minnet. Men i tilfelle av malloc()-funksjonen, må vi bruke free()-funksjonen for å deallokere minnet.
Syntaks for ny operatør
type reference_variable = new type name;
hvor,
type: Den definerer datatypen til referansevariabelen.
referansevariabel: Det er navnet på pekervariabelen.
sammenkoblingsstreng i java
ny: Det er en operatør som brukes til å tildele minnet.
type navn: Det kan være en hvilken som helst grunnleggende datatype.
For eksempel,
int *p; p = new int;
I setningene ovenfor erklærer vi en heltallspekervariabel. Uttalelsen p = ny int; tildeler minneplassen for en heltallsvariabel.
Syntaksen til malloc() er gitt nedenfor:
int *ptr = (data_type*) malloc(sizeof(data_type));
ptr: Det er en pekervariabel.
data-type: Det kan være en hvilken som helst grunnleggende datatype.
For eksempel,
hva er regex java
int *p; p = (int *) malloc(sizeof(int))
Utsagnet ovenfor vil tildele minnet for en heltallsvariabel i en haug, og lagrer deretter adressen til det reserverte minnet i 'p'-variabelen.
- På den annen side kan minnet som er allokert ved hjelp av malloc()-funksjonen deallokeres ved hjelp av free()-funksjonen.
- Når minnet er tildelt ved hjelp av den nye operatøren, kan det ikke endres størrelse. På den annen side er minnet allokert ved hjelp av malloc()-funksjonen; deretter kan den omfordeles ved hjelp av realloc()-funksjonen.
- Utførelsestiden til new er mindre enn malloc()-funksjonen da new er en konstruksjon, og malloc er en funksjon.
- Den nye operatøren returnerer ikke den separate pekervariabelen; den returnerer adressen til det nyopprettede objektet. På den annen side returnerer malloc()-funksjonen void-pekeren som kan skrives videre i en spesifisert type.