DynamicArray.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <algorithm>
#include <stdexcept>
using namespace std;

template<class T> class DynamicArray;
template<class T> ostream& operator<<(ostream& os, const DynamicArray<T>& array);

template<class T>
class DynamicArray {
public:
    
public:
    // Init
    DynamicArray();
    DynamicArray(int capacity);
    // Destroy
    ~DynamicArray();

    T& operator[](const unsigned int index);

    void push_back(T &t);
    void push_back(T &&t);
    T pop();
    T popByPos(int index);

    int size() const;

    friend ostream& operator<<<T>(ostream& os, const DynamicArray<T>& array);

    int capacity() const;

    bool resize(int size);

    void free();

protected:
    
private:
    // head of array
    T *ptr;
    // count of mem list
    int _capacity;
    T* begin() const;
    T* end() const;
private:
    bool make_big_ptr();
};


DynamicArray.hpp

#include "DynamicArray.h"

template<class T>
DynamicArray<T>::DynamicArray() {
    this->_capacity = 0;
    this->ptr = NULL;
}

template<class T>
DynamicArray<T>::DynamicArray(int capacity): _capacity(capacity) {
    this->ptr = NULL;
    this->ptr = new T[this->_capacity + 1];
    memset(this->ptr, 0, sizeof(T) * (this->_capacity + 1));
};

template<class T>
DynamicArray<T>::~DynamicArray() {
    if (NULL != this->ptr) {
        delete[] this->ptr;
        this->ptr = NULL;
        this->_capacity = 0;
    }
};

/******************* public : override **********************/
template<class T>
T& DynamicArray<T>::operator[](const unsigned int index) {
    if (index+1 > this->_capacity) {
        throw out_of_range("out of array range");
    }
    return *(this->ptr + index);
};

/******************* public : functions **********************/
template<class T>
void DynamicArray<T>::push_back(T &t) {
    int _size = size();
    if (_size >= _capacity) {
        int ret = make_big_ptr();
        if (ret == false) {
            return;
        }
    }
    *(ptr + _size) = t;
};

template<class T>
void DynamicArray<T>::push_back(T &&t) {
    int _size = size();
    if (_size >= _capacity) {
        int ret = make_big_ptr();
        if (ret == false) {
            return;
        }
    }
    *(ptr + _size) = t;
};

template<class T>
T DynamicArray<T>::pop() {
    T t = this->ptr[this->size() - 1];
    memset(this->ptr + this->size() - 1, 0, sizeof(T));
    return t;
};

template<class T>
T DynamicArray<T>::popByPos(int index) {
    if (index + 1 > this->size()) {
        throw out_of_range("out of array range");
    }
    T t = *(this->ptr + index);
    memcpy(this->ptr+index, this->ptr + index + 1, sizeof(T) * (this->size() - index));
    return t;
};

template<class T>
int DynamicArray<T>::size() const {
    if (this->_capacity == 0) {
        return 0;
    }
    int size = 0;
    while (*(ptr + size) != 0) {
        T t = *(ptr + size);
        size++;
    }
    return size;
};

template<class T>
int DynamicArray<T>::capacity() const {
    return _capacity;
}

template<class T>
bool DynamicArray<T>::resize(int size) {
    T* p = new T[size + 1];
    if (NULL == p) {
        return false;
    }
    memset(p, 0, sizeof(T) * (size + 1));
    if (size == this->size()) { // change capacity only
        memcpy(p, this->ptr, sizeof(T) * (size + 1));
    } else {
        if (size > this->size()) {      // add
            memcpy(p, this->ptr, sizeof(T) * (this->_capacity + 1));
        } else {
            memcpy(p, this->ptr, sizeof(T) * (size));
        }
    }
    delete[] this->ptr;
    this->ptr = p;
    this->_capacity = size;
    return true;
};

template<class T>
void DynamicArray<T>::free() {
    if (this->ptr != NULL) {
        delete[] this->ptr;
        this->ptr = NULL;
    }
    this->_capacity = 0;
};

/************************ private ***************************/
template<class T>
T* DynamicArray<T>::begin() const {
    return ptr;
};

template<class T>
T* DynamicArray<T>::end() const {
    return ptr + size();
};

/************************* friend ***************************/
template<class T>
ostream& operator<<(ostream& os, const DynamicArray<T>& array) {
    for (T* it = array.begin(); it != array.end(); it++) {
        cout << *it << " ";
    }
    return os;
};

/************************* private ***************************/
template<class T>
bool DynamicArray<T>::make_big_ptr() {
    int new_capacity = (this->_capacity == 0) ? 1 : (this->_capacity * 2);

    T* p = new T[new_capacity + 1];
    if (p == NULL) {
        return false;
    }
    memset(p, 0, sizeof(T) * (new_capacity + 1));
    if (this->_capacity > 0) {
        memcpy(p, this->ptr, sizeof(T) * (this->_capacity + 1));
    }
    if (NULL != this->ptr) {
        delete[] this->ptr;
    }
    this->ptr = p;
    this->_capacity = new_capacity;
    return true;
};