Unable to delete pointer on heap memory - c++

Question

I am making my own dynamic allocator in C++. But I ran into a problem where I can't free my memory.
This is the code for Test.cpp:
#include "Memory/MemoryManager.h"
int main(){
initMemory(1);
int* p = allocate<int>();
int* q = allocate<int>();
int* r = allocate<int>();
cout<<p<<endl;
cout<<q<<endl;
cout<<r<<endl;
freeAddress<int>(q);
return 0;
}
MemoryManager.h:
#ifndef MEMORY_MANAGER_INCLUDED
#define MEMORY_MANAGER_INCLUDED
#include <iostream>
#include <map>
#include <memory>
using namespace std;
char* memory;
char* current;
map<void*, size_t> freePointers;
void initMemory(size_t size){
memory = (char*)malloc(size);
current = memory;
}
template<typename T> T* allocate(){
T* address = NULL;
for (auto p : freePointers){
if (p.second == sizeof(T)){
address = static_cast<T*>(p.first);
}
}
if (address == NULL){
address = new(current) T();
current += sizeof(T);
}
return address;
}
template<typename T> T* allocate(size_t size){
T* address = NULL;
for (auto p : freePointers){
if (p.second == sizeof(T) * size){
return static_cast<T*>(p.first);
}
}
if (address == NULL){
address = new(current) T[size];
current += sizeof(T) * size;
}
return address;
}
template<typename T> void freeAddress(T* address){
freePointers.insert({(void*)address, sizeof(*address)});
delete address;
}
template<typename T> void freeAddress(T* address, size_t size){
freePointers.insert({(void*)address, sizeof(*address) * size});
delete [] address;
}
#endif
Output:
0x55ee37729e70
0x55ee37729e74
0x55ee37729e78
0x55ee37729e70
0x55ee37729e78
free(): invalid pointer
I know that I can't delete pointers on stack memory but I am not using it at all. Also please point out if I am doing something wrong or performance expensize. Please help.

Answer 1

You allocate a large chunk of memory with malloc, then call delete on some pointer into the allocated memory.
In your code, q is (memory + sizeof(int)). This pointer has never been returned by an allocation and therefore cannot be freed. This is the reason for the error.
Moreover, mismatching malloc with delete is undefined behavior. You should instead call free() on the original memory pointer as cleanup in the end, and never call delete on individual values.
If you want to call the destructor in freeAddress, use address->~T();.

Answer 2

You are allocating a single 1-byte block of memory one time, in your initMemory(). You are using malloc() for that allocation, so that memory block must be freed with free() when you are done using it, but you are not doing that.
Your freeAddress() is delete'ing memory that was never allocated with new. Inside of allocate(), you are using placement-new instead of new, they are not the same thing. When you use placement-new, you have to call an object's destructor manually, not free() or delete it.
And you certainly do not want to free memory that you are going to reuse later. That defeats the whole purpose of caching "freed" memory.
And new[] uses more memory than you request, so that it can store info for delete[] to know know how many elements to free, and how to free them. You won't know how much extra overhead that is, as it is implementation defined. So it is not safe to use new[] in this situation.
Try something more like this instead
#include "Memory/MemoryManager.h"
int main(){
initMemory(sizeof(int) * 3);
int* p = allocate<int>();
int* q = allocate<int>();
int* r = allocate<int>();
cout << p << endl;
cout << q << endl;
cout << r << endl;
freeAddress<int>(q);
doneMemory();
return 0;
}
#ifndef MEMORY_MANAGER_INCLUDED
#define MEMORY_MANAGER_INCLUDED
#include <iostream>
#include <map>
#include <memory>
char* memory;
char* current;
size_t available;
std::map<void*, size_t> freePointers;
void initMemory(size_t size){
memory = (char*) malloc(size);
current = memory;
available = (memory) ? size : 0;
}
void doneMemory(){
freePointers.clear();
free(memory);
memory = current = nullptr;
available = 0;
}
template<typename T>
T* allocate(){
T *address = nullptr;
for (auto iter = freePointers.begin(); iter != freePointers.end(); ++iter){
if (iter->second == sizeof(T)){
address = static_cast<T*>(iter->first);
freePointers.erase(iter);
break;
}
}
if (!address){
if (available < sizeof(T)){
return nullptr;
}
address = static_cast<T*>(current);
current += sizeof(T);
available -= sizeof(T);
}
return new(address) T();
}
template<typename T>
T* allocate(size_t count){
T *address = nullptr;
size_t size = count * sizeof(T);
for (auto iter = freePointers.begin(); iter != freePointers.end(); ++iter){
if (iter->second == size){
address = static_cast<T*>(iter->first);
freePointers.erase(iter);
break;
}
}
if (!address){
if (available < size){
return nullptr;
}
address = static_cast<T*>(current);
current += size;
available -= size;
}
for(size_t i = 0; i < count; ++i)
new(address+i) T();
}
return address;
}
template<typename T>
void freeAddress(T* address){
address->~T();
freePointers.insert({(void*)address, sizeof(T)});
}
template<typename T>
void freeAddress(T* address, size_t count){
for (size_t i = 0; i < count; ++i)
address[i].~T();
freePointers.insert({(void*)address, sizeof(T) * count});
}
#endif
That being said, this isn't a very safe or robust memory allocator, but it should get you started.
If you really want to create a custom memory allocator, you should write a class that follows the Allocator strategy, and then you can use that allocator with standard C++ containers, like std::vector. Let the compiler and standard library handle most of the hard work for you.