Basic vector class for Arduino

/*Basic Vector Class for Arduino IDE*/

template<typename Data>
typedef class vector{
	size_t d_size; // Stores no. of actually stored objects
	size_t d_capacity; // Stores allocated capacity
	Data *d_data; // Stores data
public:
	/*------------CONSTRUCTORS & DESTRUCTORS ----------*/

	vector() : d_size(0), d_capacity(0), d_data(0) {}; // Default constructor

	vector(vector const &other) : d_size(other.d_size), d_capacity(other.d_capacity), d_data(0) {
		d_data = (Data *)malloc(d_capacity*sizeof(Data));	
		memcpy(d_data, other.d_data, d_size*sizeof(Data));
	}; // Copy constuctor

	vector(Data* arr, size_t len) : d_size(len), d_capacity(len), d_data(0) {
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, arr, len*sizeof(Data));
	}; // Copy constuctor

	vector(size_t size, Data val = Data()) : d_size(size), d_capacity(size), d_data(0) {
		d_data = (Data *)malloc(d_capacity*sizeof(Data));		
		for (size_t s = 0; s < size; s++)
			d_data[s] = val;
	}; // Other constructor
	~vector() { free(d_data); }; // Destructor


	vector const &operator=(vector const &other) {
		free(d_data);
		d_size = other.d_size;
		d_capacity = other.d_capacity;
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, other.d_data,
			d_size*sizeof(Data));
		return *this;
	}; // Needed for memory management
	vector &operator=(vector &other) {
		free(d_data);
		d_size = other.d_size;
		d_capacity = other.d_capacity;
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, other.d_data,
			d_size*sizeof(Data));
		return *this;
	}; // Needed for memory management
	vector &operator=(Data arr[]) {
		free(d_data);
		size_t len = sizeof(arr) / sizeof(Data);
		d_size = len;
		d_capacity = len;
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, arr,
			d_size*sizeof(Data));
		return *this;
	}; // Needed for memory management


	/*------------CAPACITY----------*/
	size_t size() const { return d_size; }; // Size getter		
	void resize(size_t newsize, Data val = Data()) {
		while (newsize > d_capacity)
			resize_capacity();

		Data *newdata = (Data *)malloc(d_capacity*sizeof(Data));
		if (d_size > newsize) //resizes to a lower size.
			memcpy(newdata, d_data, newsize * sizeof(Data));
		else{ //d_data is bigger.
			if (d_size != 0) { memcpy(newdata, d_data, d_size * sizeof(Data)); }
			for (size_t s = d_size; s < newsize; s++)
				newdata[s] = val;
		}

		d_size = newsize;
		free(d_data);
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, newdata, d_size * sizeof(Data));
	};
	size_t capacity() const { return d_capacity; };
	boolean empty() { return d_size == 0; };
	void reserve(size_t n) { if (n > d_capacity) resize_capacity(n); };
	void shrink_to_fit() { d_size ? resize_capacity(d_size) : 0 ; };


	/*------------ELEMENT ACCESS----------*/
	Data const &operator[](size_t n) const { return d_data[n]; }; // Const getter
	Data &operator[](size_t n) { return d_data[n]; }; // Changeable getter
	Data at(size_t n){ return d_data[n]; };
	Data const at(size_t n) const{ return d_data[n]; };
	Data front(){ return d_data[0]; };
	Data const front() const{ return d_data[0]; };
	Data back(){ return d_data[d_size - 1]; };
	Data const back() const{ return d_data[d_size - 1]; };
	Data* data() { return d_data; };


	/*------------MODIFIERS----------*/
	void assign(size_t n, const Data& val){d_size = 0; resize(n, val); };
	void push_back(Data const &x) { resize(d_size+1, x);}; // Adds new value. If needed, allocates more space.
	void pop_back() { resize(d_size - 1); };
	void insert(size_t position, const Data &val){
		while (d_size +1 > d_capacity) resize_capacity();
		Data *newdata = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(newdata, d_data, position * sizeof(Data));
		newdata[position] = val;
		memcpy(newdata + position + 1, d_data + position, (d_size - position)* sizeof(Data));
		d_size++;
		free(d_data);
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, newdata, d_size*sizeof(Data));
	};
	void erase(size_t position){
		Data *newdata = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(newdata, d_data, position * sizeof(Data));
		memcpy(newdata + position, d_data + position + 1, (d_size - position - 1)* sizeof(Data)); d_size--;
		free(d_data);
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, newdata, d_size*sizeof(Data));
	};
	void erase(size_t first, size_t last){
		Data *newdata = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(newdata, d_data, first * sizeof(Data));
		memcpy(newdata + first, d_data + last + 1, (d_size - last - 1)* sizeof(Data));
		free(d_data);
		d_size -= last - first + 1;
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, newdata, d_size*sizeof(Data));
	};
	
	void swap(vector& x){
		vector temp = x;
		x = *this;
		d_capacity = temp.capacity();
		d_size = temp.size();
		free(d_data);
		d_data = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(d_data, temp.data(), d_size*sizeof(Data));
	}; //Swaps the data from vector X	
	void clear() { resize(0); };
private:
	void resize_capacity(size_t newsize) {
		d_capacity = newsize ? newsize : 1;
		d_size = d_size > d_capacity ? d_capacity : d_size;
		Data *newdata = (Data *)malloc(d_capacity*sizeof(Data));
		memcpy(newdata, d_data, d_size * sizeof(Data));
		free(d_data);
		d_data = newdata;
	}; // Changes d_data's allocated memory size.
	void resize_capacity() { resize_capacity(d_capacity * 2); };// Allocates double the old space

};