C++部分总结：实现数组类模板（构造、析构、重载）

/*===============================================
 *   文件名称：zj.h
 *   创 建 者：crx    
 *   创建日期：2023年09月07日
 *   描    述：
 ================================================*/
#ifndef _ZJ_H_
#define _ZJ_H_
#include <iostream> 
using namespace std;
const int SIZE = 1024;

template <class T>
class Arr{

    template <class C>
        friend ostream& operator<<(ostream &os,Arr<C> &obj);  //"<<"需要通过友元函数来重载
    template <class C>  
        friend istream& operator>>(istream &is,Arr<C> &obj);  //“>>”需要通过友元函数来重载

    public:
    Arr(const int size = 1024):arr(new T[size]),len(0),size(size)  //普通构造
    {
        count++;
    }

    Arr(T *p,int len)  //普通构造
    {
        arr = new T[SIZE];  //开辟空间大小为SIZE
        this->len = len;
        this->size = SIZE;
        for(int i = 0;i < this->len;i++)   //复制数组内容
        {
            arr[i] = p[i];
        }
        count++;
    }

    Arr(const Arr<T> &obj)  //深拷贝
    {
        this->arr = new T[obj.size];
        this->len = obj.len;
        this->size = obj.size;
        for(int i = 0;i < obj.len;i++)  //拷贝目标对象内容
        {
            this->arr[i] = obj.arr[i];
        }
        count++;
    }

    Arr(Arr<T> &&obj)  //移动构造
    {
        this->arr = obj.arr;   //指向目标对象的空间
        this->len = obj.len;
        this->size = obj.size;
        obj.arr = nullptr;
        count++;
    }

    ~Arr()   //析构函数
    {
        if(arr != nullptr)
        {
            delete []arr;
            count--;
        }
    }

    Arr<T> operator+(Arr<T> &obj)  //重载“+”
    {
        T buf[this->len+obj.len+1] = {0};   //存储“+“左右两边的对象内容
        int i = 0;
        for(i = 0;i < len;i++)     //复制”+“右边的对象内容
        {
            buf[i] = arr[i];
        }
        for(int j = 0;j < obj.len;j++)   //复制”+“左边的对象内容
        {
            buf[i++] = obj.arr[j];
        }
        Arr<T> temp(buf,this->len+obj.len);   //假设a=b+c;用一个临时对象temp存储b+c内容再返回temp内容赋值给a
        return temp;
    }

    Arr<T>& operator=(const Arr<T> &obj)  //重载“=”
    {
        if(obj.len >= this->size) //假设a=b+c;b+c为一个整体看作obj,假设obj的len大于等于a的空间大小
        {
            Arr<T> temp(obj);    //由于b+c为临时的，触发移动构造函数，temp.arr指向obj内容，temp的len、size也等于obj的
        }
        else   //不需要扩容
        {
            for(int i = 0;i < obj.len;i++)   //复制
            {
                this->arr[i] = obj.arr[i];
            }
            this->len = obj.len;   //更新实际长度
        }
        return *this;
    }

    T& operator[](int pos)  //重载“[]”
    {
        return this->arr[pos];
    }

    int length()  //返回实际长度
    {
        return len;
    }
    T* data()  //返回首地址
    {
        return arr;
    }

    static int getcount()  //返回对象个数 
    {
        return count;
    }

    private:
    T *arr;  
    int len; //实际长度
    int size;   //空间大小
    static int count;   //计算对象个数

};

template <class C>
int Arr<C>::count = 0;   //初始化类成员变量

    template <class C>
ostream& operator<<(ostream &os,Arr<C> &obj) //重载“<<”    ostream 为cout的类
{
    for(int i = 0;i < obj.len;i++)
    {
        os<<obj.arr[i]<<" ";
    }
    os<<endl;
    return os;
}
    template <class C>
istream& operator>>(istream &is,Arr<C> &obj)  //重载“>>”   istream为cin的类
{
    for(int i = 0;i < obj.len;i++)
    {
        is>>obj.arr[i];
    }
    return is;
}

#endif