用 C++ 语言实现 Vector 类：功能详解与代码示例

本文将介绍用 C++ 语言实现一个基本的 Vector 类，并演示其常见功能。Vector 类是动态数组的一种实现，它可以根据需要自动调整容量，并提供各种操作方法来访问和修改元素。

实现的功能

以下是 Vector 类所实现的功能：

• 构造函数:
  • 默认构造函数：创建空的 Vector 对象。
  • 复制构造函数：创建另一个 Vector 对象的副本。
• 析构函数: 释放 Vector 对象所占用的内存空间。
• 容量相关:
  • capacity(): 返回 Vector 对象当前的存储单元数。
  • size(): 返回 Vector 对象中实际存储的元素个数。
  • empty(): 判断 Vector 对象是否为空。
• 容量管理:
  • reserve(n): 将 Vector 对象的容量增大到至少为 n。
• 元素操作:
  • push_back(value): 在 Vector 对象的末尾添加一个元素。
  • pop_back(): 删除 Vector 对象的最后一个元素。
  • front(): 返回 Vector 对象第一个元素的引用。
  • back(): 返回 Vector 对象最后一个元素的引用。
  • operator[](i): 返回 Vector 对象中索引为 i 的元素的引用（不检查越界）。
  • at(i): 返回 Vector 对象中索引为 i 的元素的引用（检查越界）。
• 赋值运算符:
  • operator=(other): 将另一个 Vector 对象的内容赋予当前对象。
• 其他:
  • swap(other): 交换当前对象与另一个 Vector 对象的内容。
  • operator==(other): 比较两个 Vector 对象是否相等（值和顺序）。
  • operator<(other): 比较两个 Vector 对象的大小（字典顺序）。
  • clear(): 清空 Vector 对象的内容。

代码示例

#include <iostream>
#include <algorithm>

template <typename T>
class Vector {
private:
    T* elements;
    size_t capacity;
    size_t length;

public:
    Vector() : elements(nullptr), capacity(0), length(0) {}

    Vector(const Vector& other) : elements(nullptr), capacity(0), length(0) {
        *this = other;
    }

    ~Vector() {
        clear();
    }

    Vector& operator=(const Vector& other) {
        if (this != &other) {
            clear();

            capacity = other.capacity;
            length = other.length;

            elements = new T[capacity];
            std::copy(other.elements, other.elements + length, elements);
        }
        return *this;
    }

    size_t capacity() const {
        return capacity;
    }

    size_t size() const {
        return length;
    }

    bool empty() const {
        return length == 0;
    }

    void reserve(size_t n) {
        if (n > capacity) {
            T* newElements = new T[n];
            std::copy(elements, elements + length, newElements);
            delete[] elements;
            elements = newElements;
            capacity = n;
        }
    }

    void push_back(const T& value) {
        if (length == capacity) {
            reserve(capacity == 0 ? 1 : capacity * 2);
        }
        elements[length++] = value;
    }

    void pop_back() {
        if (!empty()) {
            --length;
        }
    }

    T& front() const {
        return elements[0];
    }

    T& back() const {
        return elements[length - 1];
    }

    T& operator[](size_t i) {
        return elements[i];
    }

    const T& operator[](size_t i) const {
        return elements[i];
    }

    T& at(size_t i) {
        if (i >= length) {
            throw std::out_of_range("Index out of range");
        }
        return elements[i];
    }

    const T& at(size_t i) const {
        if (i >= length) {
            throw std::out_of_range("Index out of range");
        }
        return elements[i];
    }

    void swap(Vector& other) {
        std::swap(elements, other.elements);
        std::swap(capacity, other.capacity);
        std::swap(length, other.length);
    }

    bool operator==(const Vector& other) const {
        if (length != other.length) {
            return false;
        }
        for (size_t i = 0; i < length; ++i) {
            if (elements[i] != other.elements[i]) {
                return false;
            }
        }
        return true;
    }

    bool operator<(const Vector& other) const {
        size_t minSize = std::min(length, other.length);
        for (size_t i = 0; i < minSize; ++i) {
            if (elements[i] != other.elements[i]) {
                return elements[i] < other.elements[i];
            }
        }
        return length < other.length;
    }

    void clear() {
        delete[] elements;
        elements = nullptr;
        capacity = 0;
        length = 0;
    }
};

int main() {
    Vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);

    Vector<int> v2 = v1;
    v2.pop_back();
    v2.push_back(4);

    v1.swap(v2);

    std::cout << "v1: ";
    for (size_t i = 0; i < v1.size(); ++i) {
        std::cout << v1[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "v2: ";
    for (size_t i = 0; i < v2.size(); ++i) {
        std::cout << v2[i] << " ";
    }
    std::cout << std::endl;

    std::cout << "v1 == v2: " << (v1 == v2 ? "true" : "false") << std::endl;
    std::cout << "v1 < v2: " << (v1 < v2 ? "true" : "false") << std::endl;

    return 0;
}

总结

这是一个基本的 Vector 类实现，可以根据需求进一步扩展和优化。例如，可以添加其他功能，例如插入元素、删除元素、查找元素等。此外，还可以使用更高级的内存管理策略，提高 Vector 类的效率。