Question

Consider the following code

struct foo
{
    const int txt_len;
    const int num_len;

    char * txt;
    int * num;

    foo(int tl, int nl): txt_len(tl), num_len(nl)
    {
        char * tmp = new char[txt_len * sizeof(char) + num_len * sizeof(int)];

        txt = new (tmp) char [txt_len * sizeof(char)];
        num = new (tmp + txt_len * sizeof(char)) int[num_len * sizeof(int)];

        // is this the same as above?
        // txt = tmp;                                  
        // num = (int *) (tmp + txt_len * sizeof(char));
    }

    ~foo()
    {
        delete[] txt; // is this the right way to free the memory?
    }
};

I want *txt and *num to be contiguous, is that the best way to do it?

also is there any difference between placement new and pointer arithmetic? which one should I use?

Answer 1

If you want a contiguous block of memory, you have to allocate it whole with a single call to operator new[] or malloc() or similar. Multiple calls to these functions do not guarantee any contiguity of allocated blocks whatsoever. You may allocate a big block and then carve parts from it as needed.

And you should delete and free() all blocks previously allocated with new and malloc(), otherwise you’ll leak memory and probably make your program unstable (it will fail to allocate more memory at some point) and exert unnecessary pressure on memory in the OS, possibly slowing down other programs or making them unstable as well.

Placement new, however, does not actually allocate any memory. It simply constructs an object at the specified location and so you don’t need to free that memory twice.

One problem that I see in your code is that it doesn’t align ints. On some platforms reading or writing integers bigger than 1 byte from/to the memory must be aligned and if it’s not, you can either read/write values from/to wrong locations or get CPU exceptions leading to termination of your program. The x86 is very permissive in this regard and won’t mind, though may tax you with degraded performance.