Question

How does an allocator create and destroy and array, for example

int* someInt = someAllocator(3);

Where without the allocator it would just be

int* someInt = new int[3];

Where the allocator is responsible for create each element and ensuring the constructor will be called.

How is the internals for an allocator written without the use of new? Could someone provide and example of the function?

I do not want to just use std::vector as I am trying to learn how an allocator will create an array.

Answer 1

The problem of general memory allocation is a surprisingly tricky one. Some consider it solved and some unsolvable 😉 If you are interested in internals, start by taking a look at Doug Lea’s malloc.

The specialized memory allocators are typically much simpler – they trade the generality (e.g. by making the size fixed) for simplicity and performance. Be careful though, using general memory allocation is usually better than a hodge-podge of special allocators in realistic programs.

Once a block of memory is allocated through the “magic” of the memory allocator, it can be initialized at container’s pleasure using placement new.

— EDIT —

The placement new is not useful for “normal” programming – you’d only need it when implementing your own container to separate memory allocation from object construction. That being said, here is a slightly contrived example for using placement new:

#include <new> // For placement new.
#include <cassert>
#include <iostream>

class A {
public:
    A(int x) : X(x) {
        std::cout << "A" << std::endl;
    }
    ~A() {
        std::cout << "~A" << std::endl;
    }
    int X;
};

int main() {

    // Allocate a "dummy" block of memory large enough for A.
    // Here, we simply use stack, but this could be returned from some allocator.
    char memory_block[sizeof(A)];

    // Construct A in that memory using placement new.
    A* a = new(memory_block) A(33);

    // Yup, it really is constructed!
    assert(a->X == 33);

    // Destroy the object, wihout freeing the underlying memory
    // (which would be disaster in this case, since it is on stack).
    a->~A();

    return 0;

}

This prints:

A
~A

— EDIT 2 —

OK, here is how you do it for the array:

int main() {

    // Number of objects in the array.
    const size_t count = 3;

    // Block of memory big enough to fit 'count' objects.
    char memory_block[sizeof(A) * count];

    // To make pointer arithmetic slightly easier.
    A* arr = reinterpret_cast<A*>(memory_block);

    // Construct all 3 elements, each with different parameter.
    // We could have just as easily skipped some elements (e.g. if we
    // allocated more memory than is needed to fit the actual objects).
    for (int i = 0; i < count; ++i)
        new(arr + i) A(i * 10);

    // Yup, all of them are constructed!
    for (int i = 0; i < count; ++i) {       
        assert(arr[i].X == i * 10);
    }

    // Destroy them all, without freeing the memory.
    for (int i = 0; i < count; ++i)
        arr[i].~A();

    return 0;

}

BTW, if A had a default constructor, you could try call it on all elements like this…

new(arr) A[count];

…but this would open a can of worms you really wouldn’t want to deal with.