C++實戰：一個輕型數組類的實現

C++實戰：一個輕型數組類的實現

說明：這個數組類可視為標準庫中vector的簡化版：支援數組的一般操作，支援複製、賦值，支援重新定義大小; 不考慮多線程，不考慮預分配額外空間以進行的效能最佳化，不設定迭代器。

#include <iostream>                 // 僅用於測試時輸出，數組類本身不需要

template <typename Type>
class Array
{
public:
    typedef unsigned int size_tp;   // 數組的尺寸（下標）類型

    Array(size_tp size = 0, Type t = Type());     // 可以用size指定初始大小，t指定初始值
    Array(const Array& array);
    ~Array();                                     // 空間自動釋放

    Type& operator[](size_tp index);              // 下標訪問（讀/寫形式）
    const Type& operator[](size_tp index) const;  // 下標訪問（唯讀形式）
    Array& operator=(const Array& rhs);           // 賦值，改變大小/內容

    size_tp get_size() const;                     // 獲得數組大小
    void resize(size_tp size);                    // 重設數組大小，若改小，則丟棄尾資料

    void push_back(const Type& value);            // 追加一個數組元素，數組大小增一

private:
    void copy(const Type *p_source, Type *p_target, size_tp size);
    size_tp _size;
    Type *_arr;
};

template <typename Type>
Array<Type>::Array(size_tp size, Type t): _size(size), _arr(size ? new Type[size] : 0)
{
    for (size_tp i = 0; i < size; ++i)      // not executed if (size == 0)
 _arr[i] = t;
}

template <typename Type>
Array<Type>::Array(const Array& array):
_size(array._size),
_arr(array._size ? new Type[array._size] : 0)
{
    copy(_array._arr, _arr, array._size);  // do nothing if (array._size == 0)
}

template <typename Type>
Array<Type>::~Array()
{
    delete[] _arr;
}

template <typename Type>
Array<Type>& Array<Type>::operator=(const Array<Type>& rhs)
{
    if (&rhs != this)
    {
 resize(rhs._size);
 copy(rhs._arr, _arr, _size);
    }
    return *this;
}

template <typename Type>
Type& Array<Type>::operator[](size_tp index)
{
    if (index >= _size)
 throw("Array::out of range");
    return _arr[index];
}

template <typename Type>
const Type& Array<Type>::operator[](size_tp index) const
{
    if (index >= _size)
 throw("Array::out of range");
    return _arr[index];
}

template <typename Type>
Array<Type>::size_tp Array<Type>::get_size() const
{
    return _size;
}

template <typename Type>
void Array<Type>::copy(const Type *p_source, Type *p_target, size_tp size)
{
    for (size_tp i = 0; i < size; ++i)      // not executed if (size == 0)
 p_target[i] = p_source[i];
}

template <typename Type>
void Array<Type>::resize(size_tp new_size)
{
    if (new_size)
    {
 Type *p = new Type[new_size];
 copy(_arr, p, _size < new_size ? _size : new_size);
 delete[] _arr;
 _arr = p;
    }
    else
    {
 delete[] _arr;
 _arr = 0;
    }
    _size = new_size;
}

template <typename Type>
void Array<Type>::push_back(const Type& value)
{
    resize(_size + 1);
    _arr[_size - 1] = value;
}

int main()                 // 主測試函數
{
    Array<int> a(30, 5);
    Array<int> b;
    b.push_back(20);
    b.push_back(100);
    a = b;
    for (Array<int>::size_tp i = 0; i < a.get_size(); ++i)
 std::cout << a[i] << std::endl;
    return 0;
}