What operator is used to create and make new object in oop?

Answer 1

By default, operator new() allocates memory on the free store (the heap). The standard defines four global operators:

The global operator new() has three standard implementations defined in :

1. void* operator new (std::size_t size);
2. void* operator new (std::size_t size, const std::nothrow_t& nothrow_value) noexcept;
3. void* operator new (std::size_t size, void* ptr) noexcept;

The first implementation allocates size bytes on the free store and returns a generic pointer (void*) to the first byte of the allocation. If the allocation fails for any reason, a std::bad_alloc exception is thrown. This operator is therefore known as a throwing allocation.

The second is the same as the first but does not throw an exception. If the allocation fails for any reason, nullptr is returned instead. this is known as a nothrow allocation.

The third version is used when (raw) memory has already been allocated and simply returns the given ptr argument. The memory referred to by ptr need not be allocated on the heap. This version is known as placement.

In all three cases, the allocated memory is simply raw, uninitialised memory (similar to what we would expect when invoking the standard global malloc() function in C).

In addition, the standard also defines global operator new[]() (also in ):

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

These versions are used when we wish to allocate an array of objects and have similar behaviours to the "normal" global operators.

Note that all these operators are defined implicitly; we do not need to explicitly include the header to use them.

In order to physically construct an object via global operator new (), the object's class must define a static member operator new (). Given that it would be tedious to do this for every class that we define, this is done implicitly for us. Thus when we invoke the following:

T* ptr = new T {args...};

T* ptr = new T[N] {args...};

we are actually invoking the following:

T* ptr = T::operator new (args...);

T* ptr = T::operator new[] (N, args...);

The (implicit) static member operator new() and operator new[]() are implementation-defined, but will generally be defined as follows:

T* T::operator new (args...) {

T* ptr = ::new (sizeof (T)); // invoke the global operator (may throw)

// initialise the memory from args...

return ptr;

}

T* T::operator new[] (std::size_t N, args...) {

T* ptr = ::new[] (N * sizeof (T)); // invoke the global operator (may throw)

// initialise the memory for each N from args...

return ptr;

}

Now we can see where the std::size_t argument passed to global operator new() actually comes from.

Given that T::operator new() is a member function, it can be overloaded on a class-by-class basis if we wish to provide our own memory management facility. We can also overload the global operator new(), however this is not recommended because there's no way of knowing how other classes we have no control over might be affected, particularly those which provide their own member operator new() overloads and which expect the default behaviour of the global operator new(). Overloading global operator new() is not for the feint-hearted, thus it is recommended you use a tried-and-tested library for global memory management rather than attempting to write your own from scratch.

Answer 2

In Java, you use the new keyword. In other OOP languages, it may be different. A typical use in Java is as follows:

MyClass x;

x = new MyClass();

// or perhaps: x = new MyClass(paramater1, parameter2);

Which can be combined into a single line:

MyClass x = new MyClass();

Here I am assuming that MyClass is some class you defined.