replace operator new with malloc

Question

I'm trying to replace operator new and delete with malloc and free (I got reasons for that). The problem is shown in code below:

std::string *temp = (std::string *)malloc(sizeof(std::string) * 2); // allocate space for two string objects.
temp[0] = "hello!";
temp[1] = "world!";
for(int i = 0; i < 2; i++)
{
    printf("%s\n", temp[i].c_str());
}
free(temp);
return 0; // causes SIGSEGV.

however..

std::string *temp = new std::string[2];
temp[0] = "hello!";
temp[1] = "world!";
for(int i = 0; i < 2; i++)
{
    printf("%s\n", temp[i].c_str());
}
delete [] temp;
return 0; // works fine

Why? and could anyone suggest me what is a right way to replace these operators with malloc and free?

Regards.

EDIT: this is just example, I'm not using standard C++ library.

EDIT: what about something like this?

class myclass
{
    public:
        myclass()
        {
            this->number = 0;
        }
        myclass(const myclass &other)
        {
            this->number = other.get_number();
        }
        ~myclass()
        {
            this->number = 0;
        }
        int get_number() const
        {
            return this->number;
        }
        void set_number(int num)
        {
            this->number = num;
        }
    private:
        int number;
};

int main(int argc, char *argv[])
{
    myclass m1, m2;
    m1.set_number(5);
    m2.set_number(3);

    myclass *pmyclass = (myclass *)malloc(sizeof(myclass) * 2);

    pmyclass[0] = myclass(m1);
    pmyclass[1] = myclass(m2);

    for(int i = 0; i < 2; i++)
    {
        printf("%d\n", pmyclass[i].get_number());
        pmyclass[i].myclass::~myclass();
    }

    free(pmyclass);

    return 0;
}

Answer 1

malloc and free do not call the constructor and destructor of C++ classes. It also does not store information about the number of elements allocated in the array (like you are doing). This means the memory is simply allocated but never initialized. You can still manually construct and destroy the object however.

You should start by constructing the object by using placement-new. This requires you to pass the a pointer to the location where the object is to be created and to specify the type of object that needs to be instantiated. For example the first line where you assign a string literal to the allocated (but uninitialized) string object would look like the following:

new(&temp[0]) std::string("hello!");

Once you are done with the strings you need to destroy them by calling their destructor directly.

temp[0].std::string::~string();

The code you posed would look something like this:

// allocate space for two string objects.
std::string *temp = (std::string *)malloc(sizeof(std::string) * 2); 

// Using placement-new to constructo the strings
new(&temp[0]) std::string("hello!");
new(&temp[1]) std::string("world!");

for (int i = 0; i < 2; i++)
{
    printf("%s\n", temp[i].c_str());
}

//  Destroy the strings by directly calling the destructor
temp[0].std::string::~string();
temp[1].std::string::~string();
free(temp);

Answer 2

If you really want to go down this rabbit hole... well, you need placement new and you need to call destructors manually. Here's how that looks:

#include <string>
#include <stdlib.h>
#include <stdio.h>

int main()
{
    std::string *temp = (std::string *)malloc(sizeof(std::string) * 2); // allocate space for two string objects.
    new (&temp[0]) std::string("hello!");
    new (&temp[1]) std::string("world!");
    for(int i = 0; i < 2; i++)
    {
        printf("%s\n", temp[i].c_str());
    }
    temp[1].std::string::~string();
    temp[0].std::string::~string();
    free(temp);
    return 0;
}

Since malloc gives you an uninitialized memory block, you need to construct the objects in the appropriate memory slots and, before freeing the memory, you have to manually destruct them.

Answer 3

You want to implement your own operator new() with malloc, not to replace operator new with malloc.

To implement operator new(), just write it like you would do with any other function.

void* operator new() (size_t sz) { return malloc(sz); }

If you want a standard-compliant version that throws std::bad_alloc on failure, just insert your code for that.

operator delete is left as an exercise for the reader, and so are operator new[]() and operator delete[]().