创建一个通用数组类模板文件

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、创建.hpp文件

二、深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作
如果只是对指针对象进行简单的赋值操作，那么两个指针会指向同一个堆区对象，可能会引发重复释放堆区空间的问题。解决办法是通过深拷贝，重新申请一个堆区空间并让指针指向他，将旧空间中的数据复制过来。

三、代码

#pragma once //防止文件重复编译
#include <iostream>
using namespace std;

template <typename T> //创建一个类模板
class MyArray
{
public:
    MyArray(int capacity);
    ~MyArray();
    MyArray(const MyArray &arr);            //拷贝构造，注意指针成员属性，实现深拷贝
    MyArray &operator=(const MyArray &arr); //赋值操作实现深拷贝
    T &operator[](int index);               //重载，[]返回arr[i]的引用对象
    int PushBack(const T &val);             //尾插法，形参为引用可插入自定义类型
    int PopBack();                          //尾删法

private:
    T *my_array_address_;   //数组指针
    int my_array_capacity_; //数组容量
    int my_array_size_;     //数组长度
};

template <typename T>             //类模板成员函数类外实现需要声明其是一个类模板
MyArray<T>::MyArray(int capacity) //构造函数模板
{
    my_array_capacity_ = capacity;       //初始化数组容量
    my_array_address_ = new T[capacity]; //在堆区创建相应容量的T类型空间
    my_array_size_ = 0;                  //数组长度初始化
}

template <typename T>
MyArray<T>::~MyArray() //析构函数
{
    if (my_array_address_ != NULL)
    {
        delete[] my_array_address_; //释放堆区空间
        my_array_address_ = NULL;   //指针指向空地址，防止野指针出现
        my_array_capacity_ = 0;     //容量清零
        my_array_size_ = 0;
        . //长度清零
    }
}

template <typename T>
MyArray<T>::MyArray(const MyArray &arr) //拷贝构造函数
{
    int this_size = 0;

    my_array_capacity_ = arr.my_array_capacity_;
    my_array_size_ = arr.my_array_size_;
    my_array_address_ = new T[my_array_capacity_]; //在堆区开辟新空间存储对象
    for (this_size = 0; this_size < my_array_size_; this_size++)
    {
        my_array_address_[this_size] = arr.my_array_address_[this_size]; //元素赋值
    }
}

template <typename T>
MyArray<T> &MyArray<T>::operator=(const MyArray &arr) //重载“=”运算符，使对象赋值时实现深拷贝
{
    int this_size = 0;
    if (my_array_address_ != NULL)
    {
        delete[] my_array_address_;
        my_array_address_ = NULL;
        my_array_capacity_ = 0;
        my_array_size_ = 0;
    }
    my_array_capacity_ = arr.my_array_capacity_;
    my_array_size_ = arr.my_array_size_;
    //  以下实现深拷贝
    my_array_address_ = new T[my_array_capacity_];
    for (this_size = 0; this_size < my_array_size_; this_size++)
    {
        my_array_address_[this_size] = arr.my_array_address_[this_size];
    }
    return *this;
};

template <typename T>
T &MyArray<T>::operator[](int index) //重载[],使对象可返回本身的引用
{
    return my_array_address_[index];
}

template <typename T>
int MyArray<T>::PushBack(const T &val) //尾插法
{
    if (my_array_size_ == my_array_capacity_)
    {
        return 0;
    }
    my_array_address_[my_array_size_] = val; //赋值
    my_array_size_++;                        //长度加一
    return 0;
}

template <typename T>
int MyArray<T>::PopBack() // 尾删法
{
    if (my_array_size_ == 0)
    {
        return 0;
    }
    my_array_size_--; //逻辑上长度减一
    return 0;
}