Delete array of classes without calling destructors

Question

Consider we create the array using this way:

T* arr = new T[num];

And now because of some reasons we understood that we need simply delete that array but without calling any T destructors.

We all know that if we write next:

delete arr;

the T destructor will be called. If we write this:

delete[] arr;

the num destructors would be called. Having played with pointers, you realize that new inserts before the result pointer the unsigned long long value that represents the number of allocated T instances. So we try to outwit the C++ trying to change that value to number of bytes that arr occupies and delete it as (char*) in hope that in this case the delete would not call the destructors for T instances and simply free occupied memory. So you write something like this:

typedef unsigned long long;
unsll & num = *(unsll)((char*)arr-sizeof(unsll));
num = num*sizeof(T);
delete ((char*)arr);

But that doesn't work and C++ creates the trigger breakpoint(run time error) when trying to delete this. So that doesn't work. And a lot of other playing with pointers doesn't work as at least some error(compile- or run-time) occurs. So the question is:

Is that possible to delete an array of classes in C++ without calling their destructors?

Answer 1

Perhaps you want ::operator delete[](arr).

(See http://en.cppreference.com/w/cpp/memory/new/operator_delete)

But this still has undefined behaviour, and is a terrible idea.

Answer 2

One simple way to deallocate without calling destructors is to separate allocation and initialization. When you take proper care of alignment you can use placement new (or the functionality of a standard allocator object) to create the object instances inside the allocated block. Then at the end you can just deallocate the block, using the appropriate deallocation function.

I can't think of any situation where this would be a smart thing to do: it smells strongly of premature optimization and X/Y-problem (dealing with problem X by imagining impractical Y as a solution, then asking only about Y).

A new-expression is designed to couple allocation with initialization, so that they're executed as an all-or-nothing operation. This coupling, and ditto coupling for cleanup and deallocation, is key to correctness, and it also simplifies things a lot (i.e., inside there's complexity that one doesn't have to deal with). Uncoupling needs to have a very good reason. Avoiding destructor calls, for e.g. purposes of optimization, is not a good reason.

Answer 3

I'm only going to address your specific question of

Is that possible to delete an array of classes in C++ without calling their destructors?

The short answer is yes.

The long answer is yes, but there's caveats and considering specifically what a destructor is for (i.e. resource clean up), it's generally a bad idea to avoid calling a class destructor.

Before I continue the answer, it should be noted that this is specifically to answer your question and if you're using C++ (vs. straight C), using this code will work (since it's compliant), but if you're needing to produce code in this way, you might need to rethink some of your design since code like this can lead to bugs/errors and general undefined behavior if not used properly.

TL;DR if you need to avoid destructors, you need to rethink your design (i.e. use copy/move semantics or an STL container instead).

You can use malloc and free to avoid constructor and destructor calls, example code:

#include <iostream>
#include <cstdio>

class MyClass {
    public:
        MyClass() : m_val(0)
        {
            this->init(42);
            std::cout << "ctor" << std::endl;
        }

        ~MyClass()
        {
            std::cout << "dtor" << std::endl;
        }

        friend std::ostream& operator<<(std::ostream& stream, const MyClass& val)
        {
            stream << val.m_val;
            return stream;
        }

        void init(int val)
        {
            /* just showing that the this pointer is valid and can
            reference private members regardless of new or malloc */
            this->_init(val);
        }

    private:
        int m_val;

        void _init(int val)
        {
            this->m_val = val;
        }   
};

template < typename Iterator >
void print(Iterator begin, Iterator end)
{
    while (begin != end) {
        std::cout << *begin << std::endl;
        ++begin;
    }
}

void set(MyClass* arr, std::size_t count)
{
    for (; count > 0; --count) {
        arr[count-1].init(count);
    }
}

int main(int argc, char* argv[])
{
    std::cout << "Calling new[10], 10 ctors called" << std::endl;
    MyClass* arr = new MyClass[10]; // 10 ctors called;
    std::cout << "0: " << *arr << std::endl;
    set(arr, 10);
    print(arr, arr+10);
    std::cout << "0: " << *arr << std::endl;
    std::cout << "Calling delete[], 10 dtors called" << std::endl;
    delete[] arr; // 10 dtors called;

    std::cout << "Calling malloc(sizeof*10), 0 ctors called" << std::endl;
    arr = static_cast<MyClass*>(std::malloc(sizeof(MyClass)*10)); // no ctors
    std::cout << "0: " << *arr << std::endl;
    set(arr, 10);
    print(arr, arr+10);
    std::cout << "0: " << *arr << std::endl;
    std::cout << "Calling free(), 0 dtors called" << std::endl;
    free(arr); // no dtors

    return 0;
}

It should be noted that mixing new with free and/or malloc with delete results in undefined behavoir, so calling MyClass* arr = new MyClass[10]; and then call free(arr); might not work as "expected" (hence the UB).

Another issue that will arise from not calling a constructor/destructor in C++ is with inheritance. The above code will work with malloc and free for basic classes, but if you start to throw in more complex types, or inherit from other classes, the constructors/destructors of the inherited classes will not get called and things get ugly real quick, example:

#include <iostream>
#include <cstdio>

class Base {
    public:
        Base() : m_val(42)
        {
            std::cout << "Base()" << std::endl;
        }

        virtual ~Base()
        {
            std::cout << "~Base" << std::endl;
        }

        friend std::ostream& operator<<(std::ostream& stream, const Base& val)
        {
            stream << val.m_val;
            return stream;
        }

    protected:
        Base(int val) : m_val(val)
        {
            std::cout << "Base(" << val << ")" << std::endl;
        }

        void _init(int val)
        {
            this->m_val = val;
        }

        int m_val;
};

class Child : public virtual Base {
    public:
        Child() : Base(42)
        {
            std::cout << "Child()" << std::endl;
        }

        ~Child()
        {
            std::cout << "~Child" << std::endl;
        }

        void init(int val)
        {
            this->_init(val);
        }
};

template < typename Iterator >
void print(Iterator begin, Iterator end)
{
    while (begin != end) {
        std::cout << *begin << std::endl;
        ++begin;
    }
}

void set(Child* arr, std::size_t count)
{
    for (; count > 0; --count) {
        arr[count-1].init(count);
    }
}

int main(int argc, char* argv[])
{
    std::cout << "Calling new[10], 20 ctors called" << std::endl;
    Child* arr = new Child[10]; // 20 ctors called;
    // will print the first element because of Base::operator<<
    std::cout << "0: " << *arr << std::endl;
    set(arr, 10);
    print(arr, arr+10);
    std::cout << "0: " << *arr << std::endl;
    std::cout << "Calling delete[], 20 dtors called" << std::endl;
    delete[] arr; // 20 dtors called;

    std::cout << "Calling malloc(sizeof*10), 0 ctors called" << std::endl;    
    arr = static_cast<Child*>(std::malloc(sizeof(Child)*10)); // no ctors
    std::cout << "The next line will seg-fault" << std::endl;
    // Segfault because the base pointers were never initialized
    std::cout << "0: " << *arr << std::endl; // segfault
    set(arr, 10);
    print(arr, arr+10);
    std::cout << "0: " << *arr << std::endl;
    std::cout << "Calling free(), 0 dtors called" << std::endl;
    free(arr); // no dtors

    return 0;
}

The above code is compliant and compiles without error on g++ and Visual Studio, but due to the inheritance, both crash when I try to print the first element after a malloc (because the base class was never initialized).

So you can indeed create and delete an array of objects without calling their constructors and destructors, but doing so results in a slew of extra scenarios you need to be aware of and account for to avoid undefined behavior or crashes, and if this is the case for your code, such that you need to ensure the destructors are not called, you might want to reconsider your overall design (possibly even use an STL container or smart pointer types).

Hope that can help.