用 C++ 实现 Vector 类：包含构造、析构、复制构造函数

本篇文章详细介绍了如何用 C++ 语言实现一个 Vector 类，包含了构造函数、析构函数、复制构造函数以及其他必要的功能，例如：获取容量、大小、判断是否为空、预留空间、添加元素、删除元素、访问元素等。

代码实现

#include <iostream>

template<class T>
class Vector {
private:
    T* data; // 存储数据的指针
    int capacity; // 存储单元数
    int size; // 当前存储的值的个数

public:
    // 构造函数
    Vector() {
        data = nullptr;
        capacity = 0;
        size = 0;
    }

    // 析构函数
    ~Vector() {
        delete[] data;
    }

    // 复制构造函数
    Vector(const Vector& other) {
        capacity = other.capacity;
        size = other.size;

        data = new T[capacity];
        for (int i = 0; i < size; i++) {
            data[i] = other.data[i];
        }
    }

    // 返回当前存储单元数
    int getCapacity() const {
        return capacity;
    }

    // 返回当前存储的值的个数
    int getSize() const {
        return size;
    }

    // 当且仅当v中不包含值时返回true
    bool isEmpty() const {
        return size == 0;
    }

    // 增大v使得容量为n
    void reserve(int n) {
        if (n > capacity) {
            T* newData = new T[n];
            for (int i = 0; i < size; i++) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
            capacity = n;
        }
    }

    // 添加value到尾部
    void pushBack(const T& value) {
        if (size == capacity) {
            reserve(capacity == 0 ? 1 : capacity * 2);
        }
        data[size] = value;
        size++;
    }

    // 删除v的最后一个元素
    void popBack() {
        if (!isEmpty()) {
            size--;
        }
    }

    // 返回指向v的第一个元素的引用
    T& front() {
        return data[0];
    }

    // 返回指向v的最后一个元素的引用
    T& back() {
        return data[size - 1];
    }

    // 返回v中下标为i的元素-不检查越界
    T& operator[](int i) {
        return data[i];
    }

    // 返回v中下标为i的元素-检查越界
    T& at(int i) {
        if (i < 0 || i >= size) {
            throw std::out_of_range('Index out of range');
        }
        return data[i];
    }

    // 将v2的拷贝赋予v1
    Vector& operator=(const Vector& other) {
        if (this != &other) {
            delete[] data;

            capacity = other.capacity;
            size = other.size;

            data = new T[capacity];
            for (int i = 0; i < size; i++) {
                data[i] = other.data[i];
            }
        }
        return *this;
    }

    // 交换v1和v2的内容
    void swap(Vector& other) {
        std::swap(data, other.data);
        std::swap(capacity, other.capacity);
        std::swap(size, other.size);
    }

    // 当v1和v2值相同，值的顺序相同 返回true否则为false
    bool operator==(const Vector& other) const {
        if (size != other.size) {
            return false;
        }
        for (int i = 0; i < size; i++) {
            if (data[i] != other.data[i]) {
                return false;
            }
        }
        return true;
    }

    // 当且仅当v1在字典顺序上小于v2时才返回true
    bool operator<(const Vector& other) const {
        int minSize = std::min(size, other.size);
        for (int i = 0; i < minSize; i++) {
            if (data[i] < other.data[i]) {
                return true;
            } else if (data[i] > other.data[i]) {
                return false;
            }
        }
        return size < other.size;
    }
};

int main() {
    // 使用示例
    Vector<int> v;
    std::cout << "Capacity: " << v.getCapacity() << std::endl; // 0
    std::cout << "Size: " << v.getSize() << std::endl; // 0
    std::cout << "Is Empty: " << (v.isEmpty() ? "true" : "false") << std::endl; // true

    v.reserve(5);
    std::cout << "Capacity: " << v.getCapacity() << std::endl; // 5

    v.pushBack(1);
    v.pushBack(2);
    v.pushBack(3);
    std::cout << "Size: " << v.getSize() << std::endl; // 3
    std::cout << "Is Empty: " << (v.isEmpty() ? "true" : "false") << std::endl; // false

    std::cout << "Front: " << v.front() << std::endl; // 1
    std::cout << "Back: " << v.back() << std::endl; // 3

    v.popBack();
    std::cout << "Size: " << v.getSize() << std::endl; // 2

    std::cout << "Element at index 1: " << v[1] << std::endl; // 2

    try {
        std::cout << "Element at index 3: " << v.at(3) << std::endl; // throws std::out_of_range
    } catch (const std::out_of_range& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }

    Vector<int> v2 = v;
    std::cout << "Is v2 equal to v? " << (v2 == v ? "true" : "false") << std::endl; // true

    Vector<int> v3;
    v3.pushBack(2);
    v3.pushBack(1);
    std::cout << "Is v3 less than v? " << (v3 < v ? "true" : "false") << std::endl; // true

    v.swap(v2);
    std::cout << "Is v2 equal to v? " << (v2 == v ? "true" : "false") << std::endl; // false
}

代码解释

1. 类定义：

   • data: 指向动态分配的数组的指针，用来存储数据。
   • capacity: 表示 data 数组的容量。
   • size: 表示当前存储的元素个数。

2. 构造函数：

   • 默认构造函数初始化 data 为 nullptr，capacity 和 size 为 0。

3. 析构函数：

   • 释放 data 指针指向的动态分配的内存空间。

4. 复制构造函数：

   • 复制 other 的 capacity 和 size 到当前对象。
   • 为当前对象分配与 other 相同大小的内存空间。
   • 逐个将 other 的元素复制到当前对象的内存空间中。

5. 成员函数：

   • getCapacity(): 返回当前 data 数组的容量。
   • getSize(): 返回当前存储的元素个数。
   • isEmpty(): 判断 Vector 是否为空。
   • reserve(int n): 预留空间，确保 data 数组的容量至少为 n。
   • pushBack(const T& value): 在 Vector 的末尾添加一个元素。
   • popBack(): 删除 Vector 末尾的元素。
   • front(): 返回第一个元素的引用。
   • back(): 返回最后一个元素的引用。
   • operator[](int i): 返回下标为 i 的元素的引用，不检查越界。
   • at(int i): 返回下标为 i 的元素的引用，检查越界。
   • operator=(const Vector& other): 赋值运算符，将 other 的内容复制到当前对象。
   • swap(Vector& other): 交换当前对象和 other 的内容。
   • operator==(const Vector& other): 判断两个 Vector 是否相等。
   • operator<(const Vector& other): 判断当前对象是否字典序小于 other。

6. 主函数：

   • 展示了 Vector 类各个成员函数的使用方法。

总结

本篇文章介绍了如何用 C++ 实现一个基本的 Vector 类，包含了构造、析构、复制构造函数以及其他必要的功能。这个 Vector 类可以作为一个基础，在实际应用中，根据需要添加其他功能和优化。

希望这篇文章对您有所帮助，如果您有任何问题，欢迎在评论区留言。