【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;
            }
        }
    }
}