Advantages of new operator over malloc function in c?

Answer 1

1: new operator automatically computes the size of the data object. You need not use the operator sizeof.

2: new operator automatically returns the correct pointer type, so that there is no need to use a type cast.

3: it is possible to initialize the object while creating the memory space.

4: Like any other operator, new and delete can be overloaded.

Answer 2

- Its the standard for object allocation in C++

- It supports strong type checking

- it has 3 characters less to type

- you dont need the typeof function as an argument (saves even more characters)

Answer 3

new calls constructor of classes and delete calls deconstructor. malloc and free dont.

also the syntax is hard with malloc

eg. malloc(int) sizeof(int) or whatever

while int * x;

x= new int(9)

Answer 4

The malloc function was inherited from C and is only required for backward compatibility with C.

The main disadvantage of malloc over the C++ new operator is that you cannot instantiate C++ objects using malloc, you can only instantiate primitive data types or POD data types; plain old data or trivial class/struct data types that behave as if they were C-style structs. Attempting to use malloc to instantiate a C++ object will result in undefined behaviour because the memory allocated to the pointer will be in an uninitialised state. That is, no constructors are invoked. Even if you can somehow initialise the data, when you subsequently free the pointer, the destructor will not be invoked, which means any resources allocated to the underlying object will not be released. The onus is therefore entirely upon the programmer to ensure all allocated resources are released before freeing any pointer to a C++ object. Even if you can manage all that by yourself, there huge are type-safety concerns, particularly when dealing with derived classes and virtual function tables. In short, there be dragons -- so don't go there.

Although you can use malloc when working with PODs and primitive data types, it really makes no sense to do so. For instance, malloc does not know how much memory to actually allocate to a particular object so you must manually tell it how much you need. In addition, the returned pointer is a void pointer, which means you must statically cast to the appropriate type. That's a lot of unnecessary work and is, ultimately, a distraction.

The new operator, on the other hand, can be used with any C or C++ data type, whether primitive, built-in or user-defined. If a non-null pointer is returned from the new operator, then the memory is guaranteed to be allocated and initialised according to whichever constructor was invoked (including any base class constructors) and is completely type-safe.

For primitive data types, there is no guarantee the memory is initialised unless you pass a value to the type's constructor, which is akin to initialising a variable at the point of instantiation. To ensure consistency when porting code to another compiler, always initialise pointers to primitive data types.

Note that although primitive data types are not implemented as objects (as they are in Java, for instance), C++ does allow object-construction syntax for any data type. This is merely sugar-coating to provide a consistent method of object construction.

Once you have a valid pointer, you can work with it just as you would a static object, except you use the pointer-to-member operator (->) instead of the member-of operator (.) to access the object's members.

Finally, when you delete a pointer allocated with new, you automatically invoke the object's destructor, including any base class destructors, which (if programmed correctly) will automatically release any and all resources allocated to the object.

In short, the onus with regards resource management is placed entirely upon the object itself. The programmer need not concern themselves with how resources are allocated and destroyed; they simply instantiate a pointer with new, use the pointer according the underlying object's interface, and delete the pointer when they are finished with it. The only things the programmer has to remember is to delete every pointer allocated with the new operator and to assign the nullptr object to any and all pointers that are not currently in use to ensure they are properly initialised. Remember C++ has no automatic garbage collection. All resources allocated by you with the new operator are your responsibility and yours alone.

Note that although resource management is much simpler with the new operator than with malloc, it's still best to avoid using new wherever you possibly can. Statically allocated objects always clean up after themselves, automatically, as soon as they fall from scope and are generally much easier to work with. Use the new operator only when static allocation is not feasible. In this way, you'll have far fewer resources to manage, which minimises the risk of leaked memory. Also, if you need to manage a lot of resources, wrap them in one or more classes and let the classes handle the resource management for you. In this way you need only instantiate static instances of those classes while the instances themselves manage the resources Behind the Scenes.

Answer 5

We never use the malloc() function in C++ unless we're actually writing C code. When we allocate memory we typically want to place one or more initialised objects in that memory, which means the class constructor for each object must be invoked automatically. But the malloc() function is a C function and C knows nothing about classes let alone constructors, so when we allocate memory all we get is the (uninitialised) memory itself; there are no valid objects allocated to that memory. This means we must use placement new in order to construct those objects in the allocated memory, but there is no equivalent of placement new in C.

In C++ the malloc() function behaves exactly as it does in C except that the returned pointer must be explicitly cast to the appropriate type. Consider the following usage:

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

if (p==nullptr) throw std::bad_alloc ();

*p = 42;

Now consider the equivalent code using operator new:

int* p = new int {42};

This single line does everything those three lines of C-style code do, including automatically throwing an exception if the allocation should fail. This means that if the exception is not thrown by operator new, p is guaranteed to point to a valid, initialised object of type int.

The operator new functions are all defined in the C++ header as follows:

1. void* operator new (std::size_t);
2. void* operator new [] (std::size_t);
3. void* operator new (std::size_t, const std::nothrow_t&) noexcept;
4. void* operator new [] (std::size_t, const std::nothrow_t&) noexcept;

These four are known as the replaceable allocation functions. Note that there are two versions of each operator, one for single objects and another for arrays of objects. The first two operators will throw a std::bad_alloc object (or one of its derivatives) upon failure while the last two will return a nullptr on failure. All four are implicitly declared in every C++ translation unit whether we include the header or not.

In addition, we also have two placement new operatorswhich are used specifically to instantiate objects in memory that has already been allocated (including memory allocated via the malloc() function):

1. void* operator new (std::size_t size, void* ptr) noexcept;
2. void* operator new [] (std::size_t size, void* ptr) noexcept;

We can use the placement new operator to instantiate objects in memory already allocated on the stack or in static memory as well as on the heap. Note that the malloc()function can only allocate memory on the heap.

Moreover, we can overload the placement new operators:

1. void* operator new ( std::size_t count, user-defined-args... );
2. void* operator new [] ( std::size_t count, user-defined-args... );

In addition, we can provide class-specific overloaded operators:

1. void* T::operator new ( std::size_t count );
2. void* T::operator new [] ( std::size_t count );
3. void* T::operator new ( std::size_t count, user-defined-args... );
4. void* T::operator new [] ( std::size_t count, user-defined-args... );

Combined, these new operators give us fine-grained control over the instantiation of our objects ensuring that whenever we hold a pointer to an object, we can be sure the object being pointed at is in a valid state (assuming its constructors are well-defined of course). We have no such guarantees with the malloc() function.

In practice we seldom use the new operators. Pointers to heap allocations are a constant source of bugs and resource leaks, so we try to avoid using them as much as is practical. We cannot avoid them completely of course, however we can easily hide pointers in resource handles such as std::vector. Arrays of pointers to a type T are a common construct in C but in C++ we can use a std::vector>instead.

Answer 6

# Advantages of using NEW over MALLOC() are:-

1.operator new can be overloaded, malloc cannot be overloaded.

2.operator new is an operator , malloc is a function.

3)operator new throws an exception if there was not enough memory , malloc returns null.

4)operator new constructs an object (calls constructor of object), malloc does not.

5)operator new/new[] must be matched with operator delete/delete[] to deallocate memory,malloc() must be matched with free() to deallocate() memory.

6)operator new() requires to specify the number of objects to allocate, malloc requires to specify the total number of bytes to allocate.

Answer 7

They are the same, and are often versions of the same routine. The difference is that operator new also invokes the constructor.

Answer 8

1. You cannot use 'delete' in C.

2. Even if you could, 'delete' and 'malloc' are completely different things.

Answer 9

Allocates memory.