Vector's push_back implementation using memcpy - c++

Question

Given the following push_back code:
template <typename T>
void Vector<T>::push_back(const T& item) {
if (_size == _capacity) {
_capacity = _capacity + (_capacity > 1 ? (_capacity / 2) : 1);
T* newVec = new T[_capacity];
memcpy(newVec, _ptr, _size*(sizeof(T)));
delete [] _ptr;
_ptr = newVec;
}
_ptr[_size++] = item;
}
While the vector's class contain these members:
T* _ptr;
size_t _size;
size_t _capacity;
Is that implementation safe..? Will memcpy do his job correctly even if T is polymorphic type?
Would love to hear some suggestions about how to improve the implementation.

Answer 1

Don't use std::memcpy
You may only use std::memcpy on trivially copyable objects. Otherwise it's undefined behaviour.
You can, however, just copy all elements by hand. std::copy is suitable, as it may be specialized for trivial types:
In practice, implementations of std::copy avoid multiple assignments and use bulk copy functions such as std::memcpy if the value type is TriviallyCopyable
template <typename T>
void Vector<T>::push_back(const T& item) {
if (_size == _capacity) {
size_t new_cap = _capacity > 0 ? 2 * _capacity : 2;
T * newVec = new T[new_cap];
std::copy(_ptr, _ptr + _size, newVec);
std::swap(_capacity, new_cap);
std::swap(_ptr, newVec);
delete[] newVec;
}
_ptr[_size++] = item;
}
Note that your original implementation divided the capacity if the vector was too small.
More improvements
If you use std::allocator (or a compatible class), things get a little bit easier. You would use .allocate to get memory, .construct(pointer, value) to actually construct objects, .destroy to call their destructors and .deallocate to remove memory previously created with .allocate. Thus you don't need a default constructible object if you just want to use .push_back().
The following code is a quick minimal sketch. Note that there are some problems, for example reserve() isn't exception safe, as the allocated memory in tmp needs to be cleaned up if a constructor throws.
template <typename T, class Allocator = std::allocator<T> >
class Vector{
public:
typedef typename Allocator::pointer pointer;
typedef typename Allocator::size_type size_type;
Vector() : _ptr(0), _capacity(0), _size(0){}
~Vector() {
if(_capacity == 0)
return;
while(_size > 0)
pop_back();
_alloc.deallocate(_ptr, _capacity);
}
void reserve(size_type new_cap){
if(new_cap <= _capacity)
return;
// allocate memory
T * tmp = _alloc.allocate(new_cap);
// construct objects
for(unsigned int i = 0; i < _size; ++i){
_alloc.construct(tmp + i, _ptr[i]); // or std::move(_ptr[i])
}
// finished construction, save to delete old values
for(unsigned int i = 0; i < _size; ++i){
_alloc.destroy(_ptr + i);
}
// deallocate old memory
_alloc.deallocate(_ptr, _capacity);
_ptr = tmp;
_capacity = new_cap;
}
void push_back(const T& val){
if(_size == _capacity)
reserve(_capacity > 0 ? 2 * _capacity : 1);
_alloc.construct(_ptr + _size, val);
_size++; // since T::T(..) might throw
}
void pop_back(){
_alloc.destroy(_ptr + _size - 1);
_size--;
}
T& operator[](size_type index){
return _ptr[index];
}
private:
pointer _ptr;
size_type _capacity;
size_type _size;
Allocator _alloc;
};

Answer 2

This is not safe, for example if T is doing this:
struct T
{
T* myself;
T() : myself(this) {}
void foo() { myself->bar(); }
void bar() { ... }
};
Since you moved the memory location of the object by simply moving it's memory without calling constructors/destructors, myself will not be updated and when you call foo afterward, it will call bar with an invalid this pointer.

Answer 3

Imagine what would happen if T was itself a vector.
Now you have two vectors pointing to the same buffer, and they will both delete the buffer... bad idea.
(Well, technically it's undefined behavior the moment you memcpy. I just gave you the most likely result.)

Answer 4

It's not safe in general - but C++11 provides std::is_trivially_copyable :
#include <type_traits>
...
if (std::is_trivially_copyable<T>::value)
// *can* use memcpy...