How to deallocate a portion of a continuous memory block?

Question

let's assume I have a structure MyStruct and i want to allocate a "big" chunk of memory like this:

std::size_t memory_chunk_1_size = 10;
MyStruct * memory_chunk_1 = reinterpret_cast <MyStruct *> (new char[memory_chunk_1_size * sizeof(MyStruct)]);

and because of the "arbitrary reasons" I would like to "split" this chunk of memory into two smaller chunks without; moving data, resizing the "dynamic array", deallocating/allocating/reallocating memory, etc.

so I am doing this:

std::size_t memory_chunk_2_size = 5;              // to remember how many elements there are in this chunk;
MyStruct * memory_chunk_2 = &memory_chunk_1[5];   // points to the 6th element of memory_chunk_1;

memory_chunk_1_size = 5;                          // to remember how many elements there are in this chunk;
memory_chunk_1 = memory_chunk_1;                  // nothing changes still points to the 1st element.

Unfortunately, when I try to deallocate the memory, I'm encountering an error:

// release memory from the 2nd chunk
for (int i = 0; i < memory_chunk_2_size ; i++)
{
    memory_chunk_2[i].~MyStruct();
}
delete[] reinterpret_cast <char *> (memory_chunk_2); // deallocates memory from both "memory_chunk_2" and "memory_chunk_1"

// release memory from the 1st chunk
for (int i = 0; i < memory_chunk_1_size ; i++)
{
    memory_chunk_1[i].~MyStruct();                   // Throws exception.
}
delete[] reinterpret_cast <char *> (memory_chunk_1); // Throws exception. This part of the memory was already dealocated.

How can I delete only a selected number of elements (to solve this error)?

Compilable example:

#include <iostream>

using namespace std;

struct MyStruct
{
    int first;
    int * second;

    void print()
    {
        cout << "- first:  " <<  first  << endl;
        cout << "- second: " << *second << endl;
        cout << endl;
    }

    MyStruct() :
        first(-1), second(new int(-1))
    {
        cout << "constructor #1" << endl;
        print();
    }

    MyStruct(int ini_first, int ini_second) :
        first(ini_first), second(new int(ini_second))
    {
        cout << "constructor #2" << endl;
        print();
    }

    ~MyStruct()
    {
        cout << "destructor" << endl;
        print();

        delete second;
    }
};

int main()
{
    // memory chunk #1:
    std::size_t memory_chunk_1_size = 10;
    MyStruct * memory_chunk_1 = reinterpret_cast <MyStruct *> (new char[memory_chunk_1_size * sizeof(MyStruct)]);

    // initialize:
    for (int i = 0; i < memory_chunk_1_size; i++)
    {
        new (&memory_chunk_1[i]) MyStruct(i,i);
    }

    // ...
    // Somewhere here I decided I want to have two smaller chunks of memory instead of one big,
    // but i don't want to move data nor reallocate the memory:

    std::size_t memory_chunk_2_size = 5;              // to remember how many elements there are in this chunk;
    MyStruct * memory_chunk_2 = &memory_chunk_1[5];   // points to the 6th element of memory_chunk_1;

    memory_chunk_1_size = 5;                          // to remember how many elements there are in this chunk;
    memory_chunk_1 = memory_chunk_1;                  // nothing changes still points to the 1st element.

    // ... 
    // some time later i want to free memory:

    // release memory from the 2nd chunk
    for (int i = 0; i < memory_chunk_2_size ; i++)
    {
        memory_chunk_2[i].~MyStruct();
    }
    delete[] reinterpret_cast <char *> (memory_chunk_2); // deallocates memory from both "memory_chunk_2" and "memory_chunk_1"

    // release memory from the 1st chunk
    for (int i = 0; i < memory_chunk_1_size ; i++)
    {
        memory_chunk_1[i].~MyStruct();                   // Throws exception.
    }
    delete[] reinterpret_cast <char *> (memory_chunk_1); // Throws exception. This part of the memory was already dealocated.

    // exit:
    return 0;
}

Answer 1

Let's be honest: this is a very bad practice ! Trying to cast new and delete and in addition call yourself destructor between the two is an evidence of low-level manual memory management.

Alternatives

The proper way to manage dynamic memory structures in contiguous blocks in C++ is to use std::vector instead of manual arrays or manual memory management, and let the library proceed. You can resize() a vector to delete the unneeded elements. You can shrink_to_fit() to say that you no longer need the extra free capacity, although it's not guaranteed that unneeded memory is released.

The use of C memory allocation functions and in particular realloc() is to be avoided, as it is very error prone, and it works only with trivially copiable objects.

Edit: Your own container

If you want to implement your own special container and must allows this kind of dynamic behaviour, due to unusual special constraints, then you should consider writing your own memory management function that would manage a kind of "private heap".

Heap management is often implement via a linked list of free chunks.
One strategy could be to allocate a new chunk when there's no sufficient contiguous memory left in your private heap. You could then offer a more permissive myfree() function that reinserts a freed or partially freed chunk into that linked list. Of course, this requires to iterate through the linked list to find if the released memory is contiguous to any other chunk of free memory in the private heap, and merge the blocks if adjacent.

I see that MyStruct is very small. Another approach could then be to write a special allocation function optimised for small fixed size blocks. There is an example in Loki's small object library that is described in depth in "Modern C++ Design".

Finally, you could perhaps have a look at the Pool library of Boost, which also offers a chunk based approach.

Answer 2

The simplest way I could think of by means of standard c++ would follow this idiomatic code:

std::vector<int> v1(1000);
auto block_start = v1.begin() + 400;
auto block_end = v1.begin() + 500;
std::vector<int> v2(block_start,block_end);
v1.erase(block_start,block_end);
v1.shrink_to_fit();

If a compiler is intelligent enough to translate such pattern to the most efficient low level OS and CPU memory management operations, is an implementation detail.

Here's the working example.

Answer 3

This kind of selective deallocation is not supported by the C++ programming language, and is probably never going to be supported.

If you intend to deallocate individual portions of memory, those individual portions need to be individually allocated in the first place.

It is possible that a specific OS or platform might support this kind of behavior, but it would be with OS-specific system calls, not through C++ standard language syntax.

Answer 4

Memory allocated with malloc or new cannot be partially deallocate. Many heaps use bins of different sized allocations for performance and to prevent fragmentation so allowing partial frees would make such a strategy impossible.

That of course does not prevent you writing your own allocator.