C++ 实现的 Vector 类：功能详解及示例

本文将介绍用 C++ 语言实现的 Vector 类，并详细讲解其功能，包括构造函数、析构函数、复制构造函数、容量、大小、清空、预留空间、添加元素、删除元素、获取首尾元素、下标访问、越界检查访问、赋值、交换、比较等操作。同时，还提供了简单的示例代码，方便读者理解和使用。

代码实现

#include <iostream>
#include <algorithm>

template <typename T>
class Vector {
private:
    T* data;          // 存储元素的数组
    size_t capacity;  // 容量
    size_t size;      // 元素个数

public:
    Vector() : capacity(0), size(0), data(nullptr) {}
    
    Vector(size_t n) : capacity(n), size(n) {
        data = new T[capacity];
    }
    
    Vector(const Vector& other) : capacity(other.capacity), size(other.size) {
        data = new T[capacity];
        std::copy(other.data, other.data + size, data);
    }
    
    ~Vector() {
        delete[] data;
    }
    
    size_t Capacity() const {
        return capacity;
    }
    
    size_t Size() const {
        return size;
    }
    
    bool Empty() const {
        return size == 0;
    }
    
    void Reserve(size_t n) {
        if (n > capacity) {
            T* newData = new T[n];
            std::copy(data, data + size, newData);
            delete[] data;
            data = newData;
            capacity = n;
        }
    }
    
    void PushBack(const T& value) {
        if (size == capacity) {
            Reserve(std::max(capacity * 2, size_t(1)));
        }
        data[size++] = value;
    }
    
    void PopBack() {
        if (size > 0) {
            size--;
        }
    }
    
    T& Front() const {
        return data[0];
    }
    
    T& Back() const {
        return data[size - 1];
    }
    
    T& operator[](size_t i) {
        return data[i];
    }
    
    const T& operator[](size_t i) const {
        return data[i];
    }
    
    T& At(size_t i) {
        if (i >= size) {
            throw std::out_of_range('Index out of range');
        }
        return data[i];
    }
    
    const T& At(size_t i) const {
        if (i >= size) {
            throw std::out_of_range('Index out of range');
        }
        return data[i];
    }
    
    Vector& operator=(const Vector& other) {
        if (this != &other) {
            delete[] data;
            capacity = other.capacity;
            size = other.size;
            data = new T[capacity];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }
    
    void Swap(Vector& other) {
        std::swap(capacity, other.capacity);
        std::swap(size, other.size);
        std::swap(data, other.data);
    }
    
    bool operator==(const Vector& other) const {
        if (size != other.size) {
            return false;
        }
        for (size_t i = 0; i < size; i++) {
            if (data[i] != other.data[i]) {
                return false;
            }
        }
        return true;
    }
    
    bool operator<(const Vector& other) const {
        size_t minSize = std::min(size, other.size);
        for (size_t i = 0; i < minSize; i++) {
            if (data[i] < other.data[i]) {
                return true;
            }
            if (data[i] > other.data[i]) {
                return false;
            }
        }
        return size < other.size;
    }
};

int main() {
    Vector<int> v;
    v.PushBack(1);
    v.PushBack(2);
    v.PushBack(3);
    
    std::cout << "Capacity: " << v.Capacity() << std::endl;
    std::cout << "Size: " << v.Size() << std::endl;
    std::cout << "Empty: " << std::boolalpha << v.Empty() << std::endl;
    
    v.Reserve(10);
    
    std::cout << "Capacity after reserve: " << v.Capacity() << std::endl;
    
    v.PopBack();
    
    std::cout << "Size after pop back: " << v.Size() << std::endl;
    std::cout << "Front: " << v.Front() << std::endl;
    std::cout << "Back: " << v.Back() << std::endl;
    
    v[0] = 4;
    
    try {
        std::cout << "At index 2: " << v.At(2) << std::endl;
    } catch (const std::out_of_range& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }
    
    Vector<int> v2 = v;
    v2.PushBack(5);
    std::cout << "v == v2: " << std::boolalpha << (v == v2) << std::endl;
    std::cout << "v < v2: " << std::boolalpha << (v < v2) << std::endl;
    
    v.Swap(v2);
    std::cout << "After swap:" << std::endl;
    std::cout << "v[0]: " << v[0] << std::endl;
    std::cout << "v2[0]: " << v2[0] << std::endl;
    
    return 0;
}

功能详解

构造函数

• 默认构造函数：创建一个空的 Vector 对象，容量和大小都为 0。
• 带参数构造函数：创建一个指定大小的 Vector 对象，容量和大小都为参数值，并初始化所有元素。
• 复制构造函数：创建一个新的 Vector 对象，作为另一个 Vector 对象的副本。

析构函数

• 析构函数负责释放动态分配的内存。

成员函数

• Capacity()：返回当前存储单元数（容量）。
• Size()：返回当前存储在 Vector 中值的个数（大小）。
• Empty()：当且仅当 Vector 中不包含值时返回 true。
• Reserve(size_t n)：增大 Vector 的容量，使其至少为 n。
• PushBack(const T& value)：在 Vector 尾部添加一个元素。
• PopBack()：删除 Vector 的最后一个元素。
• Front()：返回指向 Vector 的第一个元素的引用。
• Back()：返回指向 Vector 的最后一个元素的引用。
• operator[](size_t i)：返回 Vector 中下标为 i 的元素的引用，不检查越界。
• At(size_t i)：返回 Vector 中下标为 i 的元素的引用，检查越界，越界则抛出异常。
• operator=(const Vector& other)：将另一个 Vector 对象的副本赋予当前对象。
• Swap(Vector& other)：交换当前对象和另一个 Vector 对象的内容。
• operator==(const Vector& other)：当且仅当两个 Vector 对象的值相同，值的顺序也相同，返回 true。
• operator<(const Vector& other)：当且仅当当前 Vector 对象在字典顺序上小于另一个 Vector 对象时，返回 true。

示例代码

上述代码中包含了简单的示例代码，演示了如何使用 Vector 类进行各种操作。你可以根据需要修改和扩展代码，进行更深入的测试和探索。

总结

本文介绍了用 C++ 语言实现的 Vector 类，并详细讲解了其功能和使用方式。希望对读者理解和使用 C++ 的 Vector 类有所帮助。