Calling constructors in c++ without new

In C++, constructors are typically automatically invoked when creating instances of a class, commonly through the use of the new keyword to allocate memory and initialize the object. However, constructors can also be called without using new. This can be achieved in several ways:

1. Creating Objects on the Stack

In C++, objects can be directly created on the stack, and the constructor is automatically invoked when the object is declared. For example:

cpp
class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
};

int main() {
    MyClass obj;  // Creating an object on the stack, constructor is called automatically
    return 0;
}

In this example, when MyClass obj; is executed, the constructor for MyClass is called without using new.

2. Global or Static Objects

When global or static objects are defined, their constructors are automatically called before the program starts (for global objects) or before the first use (for static objects). For example:

cpp
class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
};

MyClass globalObj;  // Global object

int main() {
    static MyClass staticObj;  // Static object
    return 0;
}

In this example, the constructors for globalObj and staticObj are called without using new.

3. Using Placement New on Pre-allocated Memory

This is a special case where, although the new keyword is technically used, it is not for memory allocation. It is used to initialize objects on already allocated memory. For example:

cpp
#include <new> // Must include this header

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
};

int main() {
    char buffer[sizeof(MyClass)];  // Allocate sufficient memory
    MyClass *obj = new(buffer) MyClass();  // Construct object on buffer
    obj->~MyClass();  // Explicitly call destructor
    return 0;
}

Although this example uses new, the key point is that no new memory is allocated; instead, the object is constructed on pre-allocated memory.

Summary

In C++, while new is commonly used to create objects and call constructors, it is possible to call constructors without explicitly using new by creating objects on the stack, using global or static objects, or employing placement new on pre-allocated memory. Typically, new is used for heap allocation, but in certain scenarios, alternatives exist when new is not desired or feasible.

1. Creating Objects on the Stack

In C++, the most straightforward approach is to create objects on the stack by directly declaring variables, which automatically invokes the constructor. For example:

cpp
class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
};

int main() {
    MyClass myObject;  // Constructor is called here
    return 0;
}

In this example, when MyClass myObject; is executed, the default constructor for MyClass is invoked.

2. Using std::make_unique or std::make_shared

If heap allocation is needed but direct new usage is avoided, smart pointers like std::unique_ptr or std::shared_ptr can be used. These provide factory functions std::make_unique and std::make_shared to create objects. For example:

cpp
#include <memory>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
};

int main() {
    auto myObject = std::make_unique<MyClass>();  // Constructor is called here
    return 0;
}

This method avoids using new and automatically manages memory, preventing memory leaks.

3. Using Placement New in Pre-allocated Memory

Although this method still uses new, it differs significantly from direct heap allocation. Placement new allows constructing objects on already allocated memory, useful for memory pools or buffer management. For example:

cpp
#include <new>  // Must include this header

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }
};

int main() {
    char buffer[sizeof(MyClass)]; // Allocate sufficient memory
    MyClass* myObject = new (buffer) MyClass(); // Constructor is called here
    myObject->~MyClass(); // Must manually call destructor
    return 0;
}

Here, the MyClass object is constructed in the pre-allocated buffer memory. This method requires manually calling the destructor, as C++ does not automatically call it on buffer.

These methods demonstrate several ways to create objects in C++ without directly using the new keyword. Each method is suitable for different scenarios and requirements.