Шаблонный класс динамического массива. Тип элементов char*

#include <iostream>
#include <cstring>
 
using namespace std;
 
struct Vec2;
 
 
template <typename T, int Nup>
class DynArray
{
  T* array;
  int Capacity;
  int length = 0;
 
  void alloc(int newCapacity)
  {
    if (newCapacity <= Capacity) return;
    T* newArray = new T[newCapacity];
    for(int i = 0; i < newCapacity; ++i)
    {
      if (i < Capacity)
      {
        newArray[i] = array[i];
      }
      else
      {
        newArray[i] = 0;
      }
    }
    delete[] array;
    array = newArray;
    Capacity = newCapacity;
  }
 
  void malloc()
  {
    array = new T[Capacity];
    for(int i = 0; i < Capacity; ++i)
      array[i] = 0;
  }
 
public:
 
  DynArray(int Capacity=0) : Capacity(Capacity)
  {
    malloc();
  }
 
  DynArray(DynArray& otherObj)
  {
          cout<<endl<<"copy ctor!"<<endl;
          Capacity = otherObj.getCapacity();
          malloc();
          length = otherObj.getLength();
          for (int i = 0; i < length; ++i)
          {
            array[i] = otherObj[i];
          }
  }
  
    DynArray& operator= (DynArray& otherObj)
    {
        if ( &otherObj != this)
        {
            cout<<endl<<"oper prisvo!"<<endl;
            delete[] array;
            Capacity = otherObj.getCapacity();
              malloc();
              length = otherObj.getLength();
              for (int i = 0; i < length; ++i)
              {
                array[i] = otherObj[i];
              }
        }
        else
        {
            cout << "Была остановленна попытка самоприсваиванья. " << endl;
        }
        
        return *this;
    }
 
  ~DynArray() { delete[] array; }
 
  T& operator[](int index) const
  {
    return array[index];
  }
 
  void reserve(int n) { alloc(Capacity + Nup); }
 
  DynArray& insert(T elem, int pos = -1)
  {
    pos = pos < 0 ? length : pos;
    //alloc(length + 1);
    if (Capacity < length + 1) { alloc(length + Nup); }
    for(int i = length - 2; i >= pos; ++i)
      array[i+1] = array[i];
    array[pos] = elem;
    length += 1;
    return *this; 
  }
  
  DynArray& operator+ (T elem)
  {
    insert(elem);
    return *this;
  }
  
  DynArray& remove(const T& elem, int pos = -1)
  {
    if(pos == -1)
    {
        for(int i = 0; i < length; ++i)
        {
            if(elem == array[i])
            {
                pos = i;
                break;
            }
        }
    }
    if(pos != -1 && pos < length)
    {
        for(int i = pos + 1; i < length; ++i)
        {
            array[i - 1] = array[i];
        }
        length -= 1;
    }
    return *this;
  }
    
  DynArray& operator- (T elem)
  {
    remove(elem);
    return *this;
  } 
  
 
  void print();
  int getLength() const { return length; }
  int getCapacity() const { return Capacity; }
  bool isEmpty() const { return length == 0; }  
  
  bool operator== (DynArray<T, Nup>& b)
    {
        if (this->getLength() == b.getLength())
        {
            for(int i=0; i < b.getLength(); ++i)
            {
                if (array[i] != b[i])
                {
                    return false; break;
                }
            }
            return true;
        }
        else
        {
            return false;
        }
    }
    
    bool operator!= (DynArray<T, Nup>& b)
    {
        if (this->getLength() == b.getLength())
        {
            for(int i=0; i < b.getLength(); ++i)
            {
                if (array[i] != b[i])
                {
                    return true; break;
                }
            }
            return false;
        }
        else
        {
            return true;
        }
    }   
 
  
  
};
 
 
 
 
template <typename T, int Nup>
void DynArray<T, Nup>::print()
{
  for(int i = 0; i < length; ++i)
    cout << array[i] << " ";
  cout << endl;
}
 
template <typename T, int Nup>
ostream& operator<<(ostream & os, const DynArray<T, Nup> & arr)
{
  for(int i = 0; i < arr.getLength(); ++i)
    cout << arr[i] << " ";
  cout << endl;
}
 
 
/*template <int Nup>
void DynArray<char*, Nup>::print()
{
  for(int i = 0; i < length; ++i)
    cout << array[i] << " ";
  cout << endl;
}*/
 
struct Vec2
{
  float x = 0, y = 0;
  
  Vec2(float a = 0) : x(a), y(a) {} 
  
  Vec2& operator=(float value)
  {
    x = y = value;
    return *this;
  }
  
  bool operator== (Vec2& b) const
    {
        if (x == b.x) {return true; }
        else { return false; }
    }
};
 
 
ostream& operator<<(ostream& os, const Vec2& vec)
{
  return os << " vec: " << vec.x << " " << vec.y;
}
 
int main(int argc, char** argv)
{
  system("chcp 1251");
    const int M = 3;
  cout << "Шаблон DynArray<int>:" << endl;
  DynArray<int, M> intArray(10);
  intArray+1+2+3;
  intArray.print();
  DynArray<int, M> iAr2(10);
  iAr2+2+3+4+1;
  cout << iAr2;
  intArray = iAr2;
  cout << intArray;
 
 
  
  cout << "check char*" << endl;
  DynArray<char*, M> ca(1);
  ca+"hi";
  ca+"world!";  
  cout << ca;
  ca-"world!";
  cout << ca;
  DynArray<char*, M> ca2 = ca;
  cout << ca2;
  if (ca2 == ca)
  {
    cout << "odinakivie" << endl;
  }
 
  return 0;
}