Custom Memory Allocator Example (Need some clarification) - c++

Question

Just running through this example of a custom memory allocator header file and I was just wanting to understand some of the written code better.
class Allocator
{
public:
Allocator(size_t size, void* start)
{
_start = start;
_size = size;
_used_memory = 0;
_num_allocations = 0;
}
virtual ~Allocator()
{
ASSERT(_num_allocations == 0 && _used_memory == 0);
_start = nullptr;
_size = 0;
}
virtual void* allocate(size_t size, u8 alignment = 4) = 0;
virtual void deallocate(void* p) = 0;
void* getStart() const
{
return _start;
}
size_t getSize() const
{
return _size;
}
size_t getUsedMemory() const
{
return _used_memory;
}
size_t getNumAllocations() const
{
return _num_allocations;
}
protected:
void* _start;
size_t _size;
size_t _used_memory;
size_t _num_allocations;
};
namespace allocator
{
template <class T> T* allocateNew(Allocator& allocator)
{
return new (allocator.allocate(sizeof(T), __alignof(T))) T;
}
template <class T> T* allocateNew(Allocator& allocator, const T& t)
{
return new (allocator.allocate(sizeof(T), __alignof(T))) T(t);
}
template<class T> void deallocateDelete(Allocator& allocator, T& object)
{
object.~T();
allocator.deallocate(&object);
}
template<class T> T* allocateArray(Allocator& allocator, size_t length)
{
ASSERT(length != 0);
u8 headerSize = sizeof(size_t)/sizeof(T);
if(sizeof(size_t)%sizeof(T) > 0)
headerSize += 1;
//Allocate extra space to store array length in the bytes before the array
T* p = ( (T*) allocator.allocate(sizeof(T)*(length + headerSize), __alignof(T)) ) + headerSize;
*( ((size_t*)p) - 1 ) = length;
for(size_t i = 0; i < length; i++)
new (&p[i]) T;
return p;
}
template<class T> void deallocateArray(Allocator& allocator, T* array)
{
ASSERT(array != nullptr);
size_t length = *( ((size_t*)array) - 1 );
for(size_t i = 0; i < length; i++)
array[i].~T();
//Calculate how much extra memory was allocated to store the length before the array
u8 headerSize = sizeof(size_t)/sizeof(T);
if(sizeof(size_t)%sizeof(T) > 0)
headerSize += 1;
allocator.deallocate(array - headerSize);
}
};
Why is the start parameter needed/used here? If I wanted to allocate some space don't I just need to specify how much memory I need to allocate?
If I wanted to just create a simple linear custom memory allocater, would I still need to include the first two templates?
For this snippet new (&p[i]) T; why is the template type name at the end?
Thanks!

Answer 1

1) start stores the pointer to a "really" allocated memory that is being allocated by this allocator and later needs to be passed to corresponding free function.
2) i think it would be better to write your allocator from scratch
3) this expression is a placement new operator invocation and &p[i] is an address where an object of type T will be constructed