vector模拟实现(简略版)

简单讲一下自己实现的一些注意的点。

难点有两个,一个是reserve函数扩容,关于浅拷贝(用memcpy浅)的解决问题,博主用了赋值来解决(调用vector<T>中的T类型的赋值)。

另一个是关于insert和erase函数的返回值的思考,(还是扩容或(缩容/删除最后一个val)所造成的迭代器失效问题)

除此之外并无太多难点。

源码:

vector.h

#pragma once
#include<iostream>

namespace bit
{
    template<class T>
    class vector
    {
    public:
        // Vector的迭代器是一个原生指针
        typedef T* iterator; 
        typedef const T* const_iterator;
        iterator begin() {
            return _start; 
        }
        iterator end() {
            return _finish;
        }
        const_iterator cbegin() const{
            return _start;
        }
        const_iterator cend() const {
            return _finish;
        }
        // construct and destroy
        vector() 
            :_start(nullptr)//每个构造都要这样,可以搞省缺值的
            ,_finish(nullptr)
            ,_endOfStorage(nullptr)
        {}
        vector(int n, const T& value = T())//只能搞push_back的?
            :_start(nullptr)
            ,_finish(nullptr)
            ,_endOfStorage(nullptr)
        {
            reserve(n);
            for (int i = 0; i < n; ++i) {
                push_back(value);
            }
        }
        template<class InputIterator>
        vector(InputIterator first, InputIterator last)
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            while (first != last) {
                push_back(*first);
                ++first;
            }
        }
        vector(const vector<T>& v) 
            :_start(new T [v._finish - v._start])
            ,_finish(_start + (v._finish - v._start))
            ,_endOfStorage(_finish)
        {
            //浅
            //std::memcpy(_start, v._start, sizeof(T) * (v._finish - v._start));
            for (int i = 0; i < size(); ++i) {
                (*this)[i] = v[i];
            }
        }
        vector<T>& operator= (vector<T> v) {
            swap(*this, v);
            return *this;
        }
        ~vector() {
            delete[] _start;
            _start = _finish = _endOfStorage = nullptr;
        }
        // capacity
        size_t size() const {
            return _finish - _start;
        }
        size_t capacity() const {
            return _endOfStorage - _start;
        }
        //需要<>里的类型支持swap
        void reserve(size_t n) {
            if (n <= capacity()) { //算是双重保障
                return;
            }
            vector<T> v1;
            v1._start = new T[n];
            v1._finish = v1._start + size();
            v1._endOfStorage = v1._start + n;
            //std::memcpy(v1._start, _start, sizeof(T) * size());
            for (int i = 0; i < size(); ++i) {
                v1[i] = (*this)[i];
            }
            swap(v1);//这个类里的swap_vector
        }
        void resize(size_t n, const T& value = T()) {
            if (size() >= n) {
                _finish = _start + n;
            }
            else {
                while (_finish != _start + n) {
                    push_back(value);
                }
            }
        }
        ///access///
        T& operator[](size_t pos) {//关于我这里使用*的疑问?
            return *(_start + pos);
        }
        const T& operator[](size_t pos)const {
            return *(_start + pos);
        }
        ///modify/
        void push_back(const T& x) {
            //if (_endOfStorage == _finish) {
            //    size_t newSize = capacity() == 0 ? 4 : capacity() * 2;
            //    reserve(newSize);
            //}
            //*_finish = x;
            //++_finish;
            insert(_finish, x);
        }
        void pop_back() {
            if (_start == _finish) {
                return;
            }
            --_finish;
        }
        void swap(vector<T>& v) {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endOfStorage, v._endOfStorage);
        }
        //当作这个pos是迭代器,而不是下标
        iterator insert(iterator pos, const T& x) {
            if (pos > _finish || pos < _start) {
                exit(1);
            }//该用assert的,可以知道哪里错了
            if (_finish == _endOfStorage) {
                int startPosSzie = pos - _start;
                size_t newSize = capacity() == 0 ? 4 : capacity() * 2;
                reserve(newSize);//可以改进,但懒
                pos = _start + startPosSzie;
            }
            iterator it = _finish;
            while (it != pos) {
                *it = *(it - 1);
                --it;
            }
            *pos = x;
            ++_finish;
            return pos;
        }
        iterator erase(iterator pos) {
            if (pos >= _finish || pos < _start) {
                exit(1);
            }//size() == 0排出去了
            iterator it = pos + 1;
            while (it != _finish) {
                *(it - 1) = *it;
                ++it;
            }
            --_finish;
            return pos;
        }
    private:
        iterator _start; // 指向数据块的开始
        iterator _finish; // 指向有效数据的尾
        iterator _endOfStorage; // 指向存储容量的尾
    };
}

test.cpp:

#define _CRT_SECURE_NO_WARNINGS 1
#include"vector.h"
#include<string>
using namespace bit;
void show(vector<int>& v) {
	//for (auto e : v) {
	//	std::cout << e << ' ' << std::endl;
	//}
	for (int i = 0; i < v.size(); ++i) {
		std::cout << v[i] << ' ';
	}
	std::cout << ' ' << std::endl;
}
void test01() {
	vector<int> v1;
	//vector<int> v2 = { 1, 2, 7, 3, 4, 5, 6 };//不支持
	vector<int> v3(10, 0);

	int a[] = { 1, 2, 7, 3, 4, 5, 6 };
	vector<int> v4(a, a + (sizeof(a)/ sizeof(int)));
	vector<int> v5(v4);
	show(v1);
	show(v3);
	show(v4);
	show(v5);
}

void test02(){
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	v1.push_back(6);
	show(v1);
	v1.resize(2, 8);
	show(v1);
	v1.resize(8, 8);
	show(v1);
}
void test03() {
	vector<std::string> v1;
	v1.push_back("1010101010012222");
	v1.push_back("1010101010012222");
	v1.push_back("1010101010012222");
	v1.push_back("1010101010012222");
	v1.push_back("1010101010012222");
	v1.push_back("1010101010012222");


}

int main()
{
	test02();
	return 0;
}

  • 3
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
引用和提供了关于实现vector的两种方法。其中,引用展示了一个使用reserve和push_back方法的示例,而引用展示了一个使用new和memcpy函数的示例。这两种方法都是常见的实现vector的方式。 在第一种方法中,通过reserve函数可以预留足够的内存空间,然后使用push_back函数逐个将元素添加到vector中。这种方法的好处是可以避免不必要的内存重分配,提高了效率。 而第二种方法使用new操作符在堆上分配内存空间,并使用memcpy函数将已有的vector对象的数据复制到新的内存空间中。通过这种方式,可以实现深拷贝,即两个vector对象拥有独立的内存空间。这种方法的好处是可以在不修改原始vector对象的情况下创建一个新的vector对象。 除了以上两种方法,还可以使用其他方式实现vector类。例如,可以使用动态数组来实现vector的底层数据结构,然后通过成员函数实现vector的各种操作,如增加、删除、查找等。 总结来说,c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式,也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值