C++自定義(手撕)vector類實現(xiàn)過程

更新時間：2025年09月23日 16:04:13 作者：Truelon

文章介紹了C++中std::vector的簡化實現(xiàn),涵蓋模板類定義、動態(tài)數(shù)組管理、構(gòu)造析構(gòu)函數(shù)、深拷貝機制、迭代器及容量操作等核心內(nèi)容,旨在通過手動實現(xiàn)理解其內(nèi)存管理原理和底層實現(xiàn)邏輯

引言

在C++中，std::vector 是一個非常強大的容器，能夠自動管理其內(nèi)部存儲空間的大小，使得程序員無需手動處理內(nèi)存分配和釋放。然而，理解 std::vector 內(nèi)部工作原理對于提高編程技能至關(guān)重要。

通過自己實現(xiàn)一個簡化版的 vector 類，我們可以更好地掌握其背后的核心概念。

類定義與成員變量

我們首先定義了一個模板類 vector，它接受一個類型參數(shù) T。此外，我們定義了三個成員變量：

_data：指向動態(tài)分配的數(shù)組的指針。
_size：當前元素的數(shù)量。
_capacity：分配的數(shù)組可以容納的最大元素數(shù)量。

template<typename T>
class vector {
public:
    // ... 公共接口 ...

private:
    T* _data;
    size_t _size;
    size_t _capacity;
};

構(gòu)造函數(shù)

默認構(gòu)造函數(shù)：初始化 _data 為 nullptr，_size 和 _capacity 為 0。
帶參數(shù)構(gòu)造函數(shù)：接收一個元素數(shù)量和可選的初始值，創(chuàng)建一個初始化了特定數(shù)量元素的 vector。
拷貝構(gòu)造函數(shù)：執(zhí)行深拷貝，確保每個 vector 對象都有自己的數(shù)據(jù)副本。

vector() : _data(nullptr), _size(0), _capacity(0) {}
explicit vector(size_t count, const T& value = T()) { /* 初始化邏輯 */ }
vector(const vector& vec) { /* 深拷貝邏輯 */ }

析構(gòu)函數(shù)

析構(gòu)函數(shù)負責釋放由 _data 指向的動態(tài)分配的內(nèi)存。

~vector() {
    delete[] _data;
}

深拷貝構(gòu)造函數(shù)與賦值操作

為了防止淺拷貝導致的問題（例如，多個 vector 對象指向同一塊內(nèi)存），我們實現(xiàn)了深拷貝構(gòu)造函數(shù)和賦值操作符。

vector(const vector& vec) { /* 深拷貝邏輯 */ }
vector& operator=(const vector& vec) { /* 深拷貝賦值邏輯 */ }

迭代器

提供 begin() 和 end() 方法來獲取指向向量起始和結(jié)束位置的迭代器，分別用于非常量和常量上下文。

T* begin() { return _data; }
T* end() { return _data + _size; }
const T* begin() const { return _data; }
const T* end() const { return _data + _size; }

容量與大小

size() 返回當前元素數(shù)量，而 capacity() 返回數(shù)組的最大容量。

size_t size() const { return _size; }
size_t capacity() const { return _capacity; }

元素操作

push_back() 和 pop_back() 用于在向量末尾添加或移除元素。insert() 和 erase() 用于在任意位置插入或刪除元素。

void push_back(T val);
void pop_back();
void insert(size_t index, const T& value);
void erase(size_t index);

輔助函數(shù)

resize() 函數(shù)用于在必要時調(diào)整向量的容量。

void resize(size_t new_capacity);

完整代碼

#include <iostream>
#include <vector>

// 定義一個名為mv的命名空間
namespace mv {
    // 定義一個模板類vector
    template<typename T>
    class vector {
    public:
        // 定義類型別名
        typedef T val_type;
        typedef val_type* iterator;

        // 默認構(gòu)造函數(shù)
        vector() : _data(nullptr), _size(0), _capacity(0) {}

        // 析構(gòu)函數(shù)，用于釋放動態(tài)分配的內(nèi)存
        ~vector() {
            delete[] _data;
        }

        // 帶參數(shù)的構(gòu)造函數(shù)，初始化vector大小和默認值
        explicit vector(size_t count, const val_type& value = val_type())
            : _data(new val_type[count]), _size(count), _capacity(count) {
            for (size_t i = 0; i < count; ++i) {
                _data[i] = value;
            }
        }

        // 深拷貝構(gòu)造函數(shù)，避免淺拷貝的問題
        vector(const vector& vec) {
            _capacity = vec._capacity;
            _data = new val_type[_capacity]; // 分配新的內(nèi)存空間
            for (size_t i = 0; i < vec._size; ++i) {
                _data[i] = vec._data[i];
            }
            _size = vec._size;
        }

        // 提供const和非const版本的begin和end方法
        iterator begin() { return _data; }
        iterator end() { return _data + _size; }
        iterator begin() const { return _data; }
        iterator end() const { return _data + _size; }

        // 返回vector的大小和容量
        size_t size() const { return _size; }
        size_t capacity() const { return _capacity; }

        // 在末尾添加一個元素
        void push_back(val_type val) {
            if (_size == _capacity) {
                resize(_capacity == 0 ? 1 : _capacity * 2);
            }
            _data[_size++] = val;
        }

        // 移除最后一個元素
        void pop_back() {
            if (_size > 0)
                --_size;
        }

        // 在指定位置插入一個元素
        void insert(size_t index, const val_type& value) {
            if (_size == _capacity) {
                resize(_capacity == 0 ? 1 : _capacity * 2);
            }
            if (index > _size) {
                std::cout << "Index out of range in insert()";
            }
            for (size_t i = _size; i > index; --i) {
                _data[i] = _data[i - 1];
            }
            _data[index] = value;
            ++_size;
        }

        // 刪除指定位置的元素
        void erase(size_t index) {
            if (index >= _size) {
                std::cout << "Index out of range in erase()";
            }
            for (size_t i = index; i < _size - 1; ++i) {
                _data[i] = _data[i + 1];
            }
            --_size;
        }

        // 判斷vector是否為空
        bool empty() { return _size == 0; }

        // 下標操作符，返回指定位置的元素
        val_type& operator[](size_t index) { return _data[index]; }

        // 比較兩個vector是否相等
        bool operator==(const vector& vec) const {
            if (_size != vec._size) return false;
            for (size_t i = 0; i < _size; ++i) {
                if (_data[i] != vec._data[i]) return false;
            }
            return true;
        }

        // 賦值操作符，實現(xiàn)深拷貝
        vector& operator=(const vector& vec) {
            if (this != &vec) { // 防止自賦值
                delete[] _data; // 釋放原有資源
                _capacity = vec._capacity;
                _data = new val_type[_capacity]; // 分配新資源
                for (size_t i = 0; i < vec._size; ++i) {
                    _data[i] = vec._data[i];
                }
                _size = vec._size;
            }
            return *this;
        }

    private:
        // 調(diào)整vector的容量
        void resize(size_t new_capacity) {
            val_type* new_data = new val_type[new_capacity];
            for (size_t i = 0; i < _size; ++i) {
                new_data[i] = _data[i];
            }
            delete[] _data;
            _data = new_data;
            _capacity = new_capacity;
        }

        // 成員變量
        val_type* _data;
        size_t _size;
        size_t _capacity;
    };
}