（C ++）STL矢量實現

Question

我已經實現了一個簡單的類似矢量的結構，如果我使用vector<int>和vector<char>它會很好地工作，但是當我使用<vector<vector<int>>它會出錯是否存在關於vector stl的良好實現代碼？我的代碼有問題嗎？

這是我的代碼

class _vector {
private:
    int _size;
    int _capacity;
    T* vc;

public:
    _vector(int size = 1) {
        _size = 0;
        _capacity = size;
        vc = new T[size];
    }
    ~_vector() {
        delete[] vc;
    }
    int size() { return _size; }
    bool empty() { return !_size; }
    void resize(int size) {
        _capacity = size;
        T* tmp = new T[size];
        for (int i = 0; i < _size; i++) tmp[i] = vc[i];
        delete[] vc;
        vc = tmp;
    }
    void clear() {
        delete[] vc;
        _capacity = 1;
        _size = 0;
        vc = new T[_capacity];
    }
    void push_back(T val) {
        if (_size == _capacity) resize(2 * _capacity);
        vc[_size++] = val;
    }
    void pop_back() {
        if (_size == 0) return;
        vc[--_size] = 0;
    }
    T& operator[](int i) const { return vc[i]; }
    _vector<T>& operator=(_vector<T> &tmp) {
        _capacity = tmp._capacity;
        _size = tmp._size;
        delete[] vc;
        vc = new T[_capacity];
        for (int i = 0; i < _size; i++) vc[i] = tmp[i];
        return *this;
    }

Answer 1

您的實現未遵循3規則 ，因為它缺少副本構造函數和適當的副本分配運算符（可以使用副本構造函數實現）。 在C ++ 11和更高版本中，通過添加move構造函數和move賦值運算符來實現5的規則。

另外，您的實現對於定義了構造函數/析構函數的非平凡類型也無法正常工作，例如T是另一種_vector類型，或者在其內部分配了指針/資源的任何其他類型時。 因此，您的類需要在將元素添加到數組中時使用placement-new構造新對象，並在從數組中刪除元素時通過直接調用其析構函數來破壞對象。

嘗試更像這樣的東西：

template <typename T>
class _vector {
public:
    typedef unsigned int size_type;
    typedef T value_type;

private:
    size_type _size;
    size_type _capacity;
    value_type* vc;

public:
    _vector(size_type initalcap = 0) : _size(0), _capacity(0), vc(0) {
        reserve(initialcap);
    }

    _vector(const _vector<T> &src) : _size(0), _capacity(0), vc(0) {
        reserve(src._capacity);
        for(size_type i = 0; i < src._size; ++i) {
            new(vc[i]) value_type(src.vc[i]);
        }
        _size = src._size;
    }

    // C++11 and later only...
    _vector(_vector<T> &&src) : _size(src._size), _capacity(src._capacity), vc(src._vc) {
        src._size = 0;
        src._capacity = 0;
        src.vc = 0;
    }

    ~_vector() {
        clear();
        delete[] reinterpret_cast<char*>(vc);
    }

    size_type size() const { return _size; }
    size_type capacity() const { return _capacity; }
    bool empty() const { return !_size; }

    void reserve(size_type newcap) {
        if (newcap <= _capacity) return;
        value_type* tmp = reinterpret_cast<value_type*>(new char[sizeof(value_type) * newcap]);
        for (size_type i = 0; i < _size; ++i) {
            new(tmp[i]) value_type(vc[i]);
        }
        delete[] reinterpret_cast<char*>(vc);
        vc = tmp;
        _capacity = newcap;
    }

    void resize(size_type newsize) {
        if (newsize < _size) {
            for(size_type i = _size; i-- > newsize; ) {
                vc[i].~value_type();
            }
            _size = newsize;
        }
        else if (newsize > _size) {
            reserve(newsize);
            for (size_type i = _size; i < newsize; ++i) {
                 new(vc[i]) value_type();
            }
            _size = newsize;
        }
    }

    void clear() {
        resize(0);
    }

    void push_back(const T &val) {
        if (_size == _capacity) reserve(2 * _capacity);
        new(vc[_size]) value_type(val);
        ++_size;
    }

    void pop_back() {
        if (_size) {
            vc[--_size].~value_type();
        }
    }

    value_type& operator[](size_type i) { return vc[i]; }
    const value_type& operator[](size_type i) const { return vc[i]; }

    _vector<T>& operator=(const _vector<T> &rhs) {
        if (&rhs != this) {
            _vector<T> tmp(rhs);
            std::swap(tmp.vc, vc);
            std::swap(tmp._size, _size);
            std::swap(tmp._capacity, _capacity);
        }
        return *this;
    }

    // C++11 and later only...
    _vector<T>& operator=(_vector<T> &&rhs) {
        _vector<T> tmp(std::move(rhs));
        std::swap(tmp.vc, vc);
        std::swap(tmp._size, _size);
        std::swap(tmp._capacity, _capacity);
        return *this;
    }
};