自定义一个动态数组

#include <iostream>
#include <string>

//
//  main.cpp
//  Xcode/Cplusplus
//
//  Created by zforw on 2021/3/2.
//

#include <iostream>
#include <algorithm>
using namespace std;

template <typename Type>
class VLA {
public:
    /*空参构造*/
    VLA() {
        _size = 0;
        elem = nullptr;
    }

    /* int capacity=10;//初始容量为10 */
        /* Type *elem[capacity];指针数组 */
    // construct with n elements of val.
    VLA(Type val, int n) {

        /*Type形参使用引用或者右值，避免不必要的拷贝*/
        _size = n;
        elem = new Type[n];
        for (int i = 0; i < n; i++) {
            elem[i] = val;
        }
    }
    // Initialize using an array
    VLA(const Type V[], int len) {
        /*Type形参使用引用或者右值，避免不必要的拷贝*/
        _size = len;
        elem = new Type[len];
        for (int i = 0; i < len; i++) {
            elem[i] = V[i];
        }
    }

    VLA(const VLA<Type>& copy) {
        _size = copy._size;
        elem = new int[copy._size];
        for (int i = 0; i < _size; ++i) {
            elem[i] = copy.elem[i];
        }
    }
    ~VLA() {
        delete[] elem;
        elem = nullptr;
    }
    void push_back(Type val) { insert(val, _size); };// insert at the end
    void insert(Type, int);     // intsert the element at a position
    void del(int);              // delete the element at a position
    void pop() { del(_size - 1); }; // pop up the last element
    int findKey(Type) const;    // find the element given by order
    void Sort();
    int size() const;           // return the _size
    VLA<Type>& operator =(const VLA<Type>& b) {
        if (this != &b) {
            if (_size) delete[] elem;
            elem = new Type[b._size];
            for (int i = 0; i < b._size; ++i) {
                elem[i] = b.elem[i];
            }
        }
        return *this;
        // return the reference of current object
        // to make sure chained assignment  a = b = c
    };
    Type operator [](int index) const {
        return elem[index];
    };
    //bool operator <(Type b) {}
private:
    
    Type* elem; // restore the elements of Type
    int _size;   // numbers of elem
};
/*应当改名为：
    Type** myElem; 或Type *myelem[capacity]; 前者为二级指针后者为指针数组
    int mySize;  

    or

    Type** m_Elem;或Type *m_elem[capacity];  前者为二级指针后者为指针数组
    int m_Size;

    为什么使用指针数组(二级指针)：
    使用普通的数组，无法保存对象，必须使用指针数组才可以保存对象。而且存储指针的话，在数组的拷贝时，可以直将指针指向原数组，
    不必对对象中的数据进行拷贝，更加高效，且部分对象没有拷贝函数，直接复制会出错。
    
    为什么改名：
    变量应当遵守命名规范，规范的命名可以让其他人快速熟悉你写的代码，详细的命名规则，可以参看各家大厂的书面文件。
    */

template <typename Type>
void VLA<Type>::insert(Type val, int pos) {
    /*这个传入应该使用引用或者右值，防止拷贝*/
    /*判断pos是否在合理范围*/
    /*临时变量应该用t_Elem或tElem*/
    Type* _elem = elem; //restore the original data   
    elem = new Type[++_size]; //allocate a new pointer
    for (int i = 0; i < pos; ++i) {
        elem[i] = _elem[i];//copy the orijginal data from 0 to pos - 1
    }

    /*这种插入仅仅适用于基本变量，如果Type是对象就会出错。所以应当使用指针数组。*/
    elem[pos] = val; // set the value

    for (int i = pos + 1; i < _size; ++i) {
        elem[i] = _elem[i - 1];//copy the remaining values
    }
    delete[] _elem;// free the memory
    /*无用的赋值，在变量明确弃用的时候，不需要为指针写入nullptr*/
    _elem = nullptr;
}

template <typename Type>
void VLA<Type>::del(int pos) {
    if (pos < 0 || pos >= _size)
        return;

    for (int i = pos; i < _size; ++i) {
        elem[i] = elem[i + 1];
    }
    _size--;

    /*删除不需要重新分配空间*/
    Type* _elem = elem;
    elem = new Type[_size];
    for (int i = 0; i < _size; ++i) {
        elem[i] = _elem[i];
    }
    delete[] _elem;
    _elem = nullptr;
}

template <typename Type>
int VLA<Type>::findKey(Type k) const {

    /*这个形参应该使用引用，防止拷贝*/

    for (int i = 0; i < _size; ++i) {
        if (elem[i] == k)
            return i;
    }
    return -1; // not found
}

template <typename Type>
void VLA<Type>::Sort() {
    sort(elem, elem + _size); // using STL
}

template <typename Type>
int VLA<Type>::size() const {
    return _size;
}

int main() {
    int b[] = { 1, 2, 3 };
    VLA<int> c(b, 3);
    VLA<int> a(0, 1);
    for (int i = 10; i >= 1; --i) {
        a.push_back(i);
    }
    a.push_back(11);
    for (int i = 0; i < a.size(); ++i) {
        cout << a[i] << " ";
    }
    cout << endl;
    a.pop();
    for (int i = 0; i < a.size(); ++i) {
        cout << a[i] << " ";
    }
    cout << endl;
    a.Sort();
    for (int i = 0; i < a.size(); ++i) {
        cout << a[i] << " ";
    }
    return 0;

    
}

/*
* 总结：
* 1、存储请使用指针数组，否则无法存储对象。
* 2、形参请尽可能使用引用或者右值，防止不必要的拷贝，在C++中，对对象进行无效的拷贝是愚蠢的。
* 3、删除不需要重新分配空间，仅仅把末尾的标志指针往左移动一位就行。
* 4、扩容可以使用翻倍扩容的方法，即每次扩容都是翻倍，删除则不重新分配空间。（这样就需要增加一个变量：capacity 数组的容量上限）
* 5、命名需要规范，比如对象的属性请使用带有my或m_前缀的标志，临时变量请使用带有t或者t_前缀的。
* 
* 
*/

【参考】邓俊辉.数据结构与算法:C++语言版第三版[M].清华大学出版社, 2013-9.