【C++基础】 MyArray 自己实现动态数组 类模板

• TestArray

  #include<iostream>
  #include"Array.h"
  using namespace std;
  ​
  int main()
  {
       char str[2];
       str[0] = 'z';
       str[1] = 'y';
       Array<char>ob(str, 2);
  ​
       cout << "Test =:" << endl;
       Array<char>copy_ob = ob;
       cout << copy_ob << endl;
  ​
       cout << "Test <<:" << endl;
       cout << ob << endl;
  ​
       cout << "Test getsize():" << endl;
       cout << ob.getSize() << endl;
  ​
       cout << "Test +:" << endl;
       Array<int>double_ob;
       cout << ob + copy_ob << endl;
  ​
       cout << "Test []:" << endl;
       cout << ob[1] << endl;
  ​
       cout << "Test sort:" << endl;
       ob.sort();
       cout << ob << endl;
  }

• Array

  #include <iostream>
  using namespace std;
  ​
  //目的：存不同类型的数据
  template <class T>
  class Array {
  private:
      int size;//数据个数
      T* arr;//数据容器
  public:
      int getSize();
      Array();  //  
      Array(int size);
      Array(const Array& other);
      Array(T[], int n);
      ~Array();
  ​
      Array& operator=(const Array& rhs);
      Array operator+(const Array& rhs) const; // append
      T& operator[](int i); //allow read and write
      const T& operator[](int n) const; // readonly    
      operator T* (); // 将动态数组对象转换为类型T *
      friend ostream& operator << <T>(ostream& out, const Array<T>& rhs);
  ​
      void sort();
  };
  ​
  template<class T>
  int Array<T>::getSize()
  {
      return size;
  }
  ​
  template<class T>
  Array<T>::Array()
  {
      size = 0;
      arr = nullptr;
  }
  ​
  template<class T>
  Array<T>::Array(int _size)
  {
      size = _size;
      arr = new T[size + 1];
  }
  ​
  template<class T>
  Array<T>::Array(const Array<T>& other)
  {
      if (size != other.size)
      {
          delete[]arr;
          size = other.size;
          arr = new T[size+1];
      }
      for (int i = 0; i < size; i++)
      {
          arr[i] = other.arr[i];
      }
  }
  ​
  template<class T>
  Array<T>::Array(T a[], int n)
  {
      size = n;
      arr = new T[size + 1];
      for (int i = 0; i < size; i++)
      {
          arr[i] = a[i];
      }
      arr[size] = '\0';
  }
  ​
  template<class T>
  Array<T>::~Array()
  {
      if (arr)
      {
          delete[]arr;
          arr = nullptr;
      }
  }
  ​
  template<class T>
  Array<T>& Array<T>::operator=(const Array& rhs)
  {
      if (size != rhs.size)
      {
          delete[]arr;
          size = rhs.size;
          arr = new T[size + 1];
      }
      for (int i = 0; i < size; i++)
      {
          arr[i] = rhs[i];
      }
      return *this;
  }
  ​
  template<class T>
  Array<T> Array<T>::operator+(const Array& rhs) const
  {
      int i = 0;
      Array temp;
      temp.size = size + rhs.size;
      temp.arr = new T[temp.size + 1];
      for (i = 0; i < size; i++)
      {
          temp.arr[i] = arr[i];
      }
      for(i=0;i<size;i++)
      {
          temp.arr[size + i] = rhs[i];
      }
      return temp;
  }
  ​
  template<class T>
  T& Array<T>::operator[](int i)
  {
      return arr[i];
  }
  ​
  template<class T>
  const T& Array<T>::operator[](int n) const
  {
      return arr[n];
  }
  ​
  template<class T>
  Array<T>::operator T* ()
  {
      return arr;
  }
  ​
  template<class T>
  ostream& operator <<(ostream& out, const Array<T>& rhs)
  {
      for (int i = 0; i < rhs.size; i++)
      {
          out << rhs.arr[i]<<" ";
      }
      out << endl;
      return out;
  }
  ​
  template<class T>
  void Array<T>::sort()
  {
      for (int i = 0; i < size; i++)
      {
          for (int j = i + 1; j < size; j++)
          {
              if (arr[i] > arr[j])
              {
                  T t  = arr[i];
                  arr[i] = arr[j];
                  arr[j] = t;
              }
          }
      }
  }