C ++向量克隆

#1 楼

#2 楼

arr = new element[size];

element get_value(int index) const;

element& operator[](int index) {
  if (index < 0 || index >= len) {
    throw "Index out of range";
  }
  return arr[index];
}

T& std::vector::operator[](index);   // Does not check index
T& std::vector::at(index);           // Does check that index is valid

for(int loop = 0; loop < v.length(); ++loop) {
    std::cout << v[loop];
}

T const& std::vector::operator[](index) const;   // Does not check index
T const& std::vector::at(index)         const;   // Does check that index is valid

  void resize(int size) {
    cap = size;
    element* newarr = new element[size];
    len = std::min(len, cap);
    for (int i=0; i < len; i++) {
      newarr[i] = arr[i];
    }

    // before you can overwrite `arr`
    // You need to deallocate the array and all its members.
    std::swap(arr, newarr);  // So swap the values.
    delete [] newarr;        // Now you can delete the old array.
  }

#3 楼

#4 楼

void append(...) {
    len += 1;
    if (len >= cap)
        allocate_to_len();
    ...
}

#5 楼

template <typename T>
class Vector {
public:
    Vector() = default;

    //  WARNING:
    //  The COPY CONSTRUCTOR, COPY ASSIGNMENT OPERATOR and DESTRUCTOR
    //  are missing and should be defined. Correctly.

    void push_back(T&& e);
    void push_back(T const& e);

private:
    using Raw = typename std::aligned_storage<sizeof(T), alignof(T)>::type;

    void grow_by(std::ptrdiff_t n);

    T* raw();

    std::ptrdiff_t mCapacity = 0;
    std::ptrdiff_t mLength = 0;
    std::unique_ptr<Raw[]> mStorage;
};


template <typename T>
void Vector<T>::push_back(T&& e) {
    this->grow_by(1);

    new (this->raw() + mLength) T{std::move(e)};
    ++mLength;
}

template <typename T>
void Vector<T>::push_back(T const& e) {
    this->grow_by(1);

    new (this->raw() + mLength) T{e};
    ++mLength;
}

template <typename T>
void Vector<T>::grow_by(std::ptrdiff_t n) {
    if (mLength + n <= mCapacity) { return; }

    //  Prepare new storage
    auto newCapacity = std::max(mCapacity, 1);
    do {
        newCapacity *= 2;
    } while (mLength + n > newCapacity);

    Vector next;
    next.mCapacity = newCapacity;
    next.mStorage.reset(new Raw[newCapacity]);

    //  Transfer objects:
    //  1. if T's move constructor is noexcept, use it!
    //  2. otherwise, if T has a copy constructor, use it!
    //  3. otherwise, use T's move constructor.
    //
    //  Cases 1 and 2 offer the Strong Exception Guarantee; case 3
    //  unfortunately offers only the Basic Exception Guarantee.
    for (auto& t : *this) {
        next.push_back(std::move_if_noexcept(t));
    }

    //  "Commit" the change.
    std::swap(*this, next);
}

template <typename T>
T* Vector<T>::raw() { return reinterpret_cast<T*>(mStorage.get()); }