I'm trying to create a ArrayList which initializes on demand instead of on construction. My previous implementation would initialize all objects including ones which were reserved for future push's but wastefully initialized.
I've got the creation working perfectly, the only issue I'm having is with the deletion, Is there a way to deconstruction a section of an array without deallocation and then deallocation of the whole array without deconstruction?
If you're asking how to recreate std::vector with separate memory allocations and object constructions, then you'll do the following:
If you're specifically asking about point 3, then destroying an object is as simple as calling the ~T() member function on it (replace T with the class name, or template type parameter you use). Look here for some example memory management: clicky.
The problem is specifically step 4, the delete[] will call the destructor, even when the object hasn't been initialized with the placement new.
As of right now I've got the manual call of the destructor, but deallocation without destruction is still an issue.
ptr = new (sizeof(T) * 5);
new (ptr) T();
&ptr[0]->~T();
delete[] ptr; // Calls the destructor on invalid objects
I've just tried casting the ptr to a char* and deleting that, but that throws a heap corruption exception. (Was hoping that the delete worked in bytes and wouldn't care)
If you delete a section of the array without freeing it's memory how are it's pointers tracked? If you stop tracking the elements you will get a memory leak which is bad.
Doesn't std::list already function how you like, could you derive or compose based on it instead?
Destructor's are called on objects, the problem stems from the array not being composed of only initialized objects.
You're doing memory allocations with the new and delete operators, not the operator new() and operator delete() functions as I mentioned. Observe the difference in terminology: the new operator is the operator that allocates memory and constructs objects, while the function operator new() is the function used to allocate the memory.
ptr = operator new(sizeof(T) * 5);
new (ptr) T();
&ptr[0]->~T();
operator delete(ptr);
The function operator new() doesn't take any type to allocate because it doesn't work with types and constructed objects, as opposed to the new operator that has to know what type to allocate and construct.
I forgot to specify that my new was using operator new(...
Although my delete was not, thank you.
template <typename T, typename A = std::allocator<T>>
class sparse_array
{
std::vector<std::aligned_union<0, T>::type, A> _data;
bit_vector<std::allocator_traits<A>::rebind_alloc<char>> _used;
public:
template <typename U>
void insert(siz_t index, U&& value)
{
if (index == _used.size())
{
_data.emplace_back();
_used.push_back(false);
}
assert(!_used[index]);
_used[index] = true;
_data.get_allocator().construct(&data[index], std::forward<U>(value));
}
template <typename U>
void push_back(U&& value)
{
auto index = _used.find_index(false);
insert(index, std::forward<U>(value));
}
T& operator[](size_t index)
{
assert(index < _used.size() && _used[index]);
return reinterpret_cast<T const&>(data[index]);
}
void clear()
{
for (size_t i = 0; i != _used.size(); ++i)
{
if (_used[i])
{
_data.get_allocator().destroy(reinterpret_cast<T*>(&_data[i]));
_used[i] = false;
}
}
}
~sparse_array() { clear(); }
sparse_array& operator=(sparse_array const& rhs); // check this!=&rhs, then clear(), then copy
sparse_array& operator=(sparse_array&& rhs); // check this!=&rhs, then clear(), then move
// ...
};ptr = new (sizeof(T) * 5);
new (ptr) T();
&ptr[0]->~T();
delete[] ptr; // Calls the destructor on invalid objectsThis is my current implementation https://github.com/Protheus-Engine/Protheus/blob/master/src/Utilities/ArrayList.h
