【C++】C++ STL探索:Vector使用与背后底层逻辑(三)

简介: 【C++】C++ STL探索:Vector使用与背后底层逻辑

【C++】C++ STL探索:Vector使用与背后底层逻辑(二)https://developer.aliyun.com/article/1617342


三、vector.h

#pragma once
#include <assert.h>
#include <iostream>
#include <algorithm>
using namespace std;
namespace bit
{
    template<class T>
        class vector
        {
            public:
            typedef  T*  iterator;
            typedef const T* const_iterator;
            iterator begin()
            {
                return _start;
            }
            iterator end()
            {
                return _finish;
            }
            const_iterator begin() const
            {
                return _start;
            }
            const_iterator end() const
            {
                return _finish;
            }
            //构造函数
            //无参构造
            vector()
            {}
            //有参构造
            //.....
            //析构
            ~vector()
            {
                delete[]_start;
                _start = nullptr;
                _finish = _end_of_storage = nullptr;
            }
            //vector<int> v1={1,2,3,4,5,6};
            vector(initializer_list<T> il)
            {
                reserve(il.size());
                for (auto& e : il)
                {
                    push_back(e);
                }
            }
            //拷贝构造
            //v2(v1)
            vector(const vector<T>& v)
            {
                //需要开一样大的空间
                reserve(v.capacity());
                for (auto& e : v)
                {
                    push_back(e);
                }
            }
            //v2 = v1;
            vector<T>& operator=(vector<T> v)
            {
                swap(v);
                return *this;
            }
            //通过下标访问
            //并且不知道会返回什么具体的类型
            T& operator[](size_t pos)
            {
                //不能等于size(),指向\0
                assert(pos < size());
                return _start[pos];
            }
            const T& operator[](size_t pos) const
            {
                assert(pos < size());
                return _start[pos];
            }
            //交换
            void swap(vector<T>& v)
            {
                std::swap(_start, v._start);
                std::swap(_start, v._start);
                std::swap(_start, v._start);
            }
            //得到当前元素空间信息
            //指针-指针
            size_t size() const
            {
                return _finish - _start;
            }
            size_t capacity() const
            {
                return _end_of_storage - _start;
            }
            //扩容
            //第一个问题,迭代器失效
            //void reserve(size_t n)
            //{
            //  if (n > capacity())
            //  {
            //    T* tmp = new T[n];
            //    memcpy(tmp, _start, size(T) * n);
            //    delete[] _start;
            //    _start = tmp;
            //    _finish =  tmpt + size();
            //    _end_of_storage =  tmp + n;
            //  }
            //}
            改良
            第二个问题,当T为自定义类型,就是浅拷贝,但是还是指向同一块空间
            //void reserve(size_t n)
            //{
            //  if (n > capacity())
            //  {
            //    size_t old_size = size();
            //    T* tmp = new T[n];
            //    memcpy(tmp, _start, size(T) * n);
            //    delete[] _start;
            //    _start = tmp;
            //    _finish =  tmp + old_size;
            //    _end_of_storage =  tmp + n;
            //  }
            //}
            正确写法
            void reserve(size_t n)
            {
                if (n > capacity())
                {
                    size_t old_size = size();
                    T* tmp = new T[n];
                    //memcpy(tmp, _start, size(T) * n);
                    for (size_t i = 0; i < old_size; i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                    _start = tmp;
                    _finish = tmp + old_size;
                    _end_of_storage = tmp +n ;
                }
            }
            //vector的迭代区间
            //函数模板
            template<class InputIterator>
                vector(InputIterator fist, InputIterator last)
            {
                while (fist != last)
                {
                    push_back(*fist);
                    ++fist;
                }
            }
            //初始化 构造
            vector(size_t n, const T& val = T())
            {
                reserve(n);
                for (size_t i = 0; i < n; i++)
                {
                    push_back(val);
                }
            }
            vector(int n, const T& val = T())
            {
                reserve(n);
                for (int i = 0; i < n; i++)
                {
                    push_back(val);
                }
            }
            //重点实现resize
            void resize(size_t n, const T& val = T())
            {
                //缩容
                if (n <= size())
                {
                    _finish = _start + n;
                }
                else
                {
                    //提前扩容
                    //大于capacity才起作用
                    reserve(n);
                    while (_finish < _start + n)
                    {
                        *_finish = val;
                        _finish++;
                    }
                }
            }
            //核心操作
            void push_back(const T& val )
            {
                insert(end(), val);
            }
            void pop_back()
            {
                /*  assert(!empty());
      _finish--;*/
                //不能--
                erase(end() - 1);
            }
            //判断空
            bool empty()
            {
                return _start == _finish;
            }
            //实现插入操作时,可能会涉及到扩容操作,就有可能出现迭代器失效的可能
            void insert(iterator pos, const T& val )
            {
                assert(_start <= pos);
                assert(pos <= _finish);
                //考虑是否需要扩容
                //说明空间已经满了
                if (_finish == _end_of_storage)
                {
                    size_t len = pos - _start;
                    //这里迭代器失效的问题
                    //不是解决了吗!当时pos没有解决呀!
                    reserve(capacity() == 0 ? 4 : capacity() * 2);
                    pos = _start + len;
                }
                //开始移动数据
                iterator it = _finish - 1;
                while (it >= pos)
                {
                    *(it + 1) = *it;
                    it--;
                }
                *pos = val;
                _finish++;
            }
            //迭代器实现erase
            iterator erase(iterator pos)
            {
                assert(_start <= pos);
                //删除不到_finish这个位置
                assert(pos < _finish);
                iterator it = pos+1;
                //it=pos+1=_finish就是最后一个位置
                while (it <= _finish)
                {
                    *(it - 1) = *(it);
                    it++;
                }
                _finish--;
                return pos;
            }
            private:
            iterator _start=nullptr;
            iterator _finish=nullptr;
            iterator _end_of_storage=nullptr;
        };
    // 函数模板
    template<class T>
        void print_vector(const vector<T>& v)
    {
        //for (size_t i = 0; i < v.size(); i++)
        //{
        //  cout << v[i] << " ";
        //}
        //cout << endl;
        //typename vector<T>::const_iterator it = v.begin();
        auto it = v.begin();
        while (it != v.end())
        {
            cout << *it << " ";
            ++it;
        }
        cout << endl;
        /*for (auto e : v)
    {
      cout << e << " ";
    }
    cout << endl;*/
    }
    void test1()
    {
        vector<int> v;
        v.push_back(12);
        v.pop_back();
        v.push_back(1);
        print_vector(v);
    }
    void test_vector2()
    {
        vector<int> v1(10, 1);
        print_vector(v1);
        vector<int> v2(10u, 1);
        print_vector(v2);
        vector<int> v3(10, 'a');
        print_vector(v3);
    }
    void test_vector3()
    {
        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);
        v1.push_back(7);
        v1.push_back(8);
        print_vector(v1);
        vector<int>::iterator it = v1.begin() + 3;
        v1.insert(it, 40);
        print_vector(v1);
        cout << *it << endl;
    }
    void test_vector4()
    {
        auto x = { 1,2,3,4,5,6 };
        cout << typeid(x).name() << endl;
        cout << sizeof(x) << endl;
    }
    void test_vector5()
    {
        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(4);
        //std::vector<int>::iterator it = v1.begin();
        vector<int>::iterator it = v1.begin();
        while (it != v1.end())
        {
            if (*it % 2 == 0)
            {
                it=v1.erase(it);
            }
            else
            {
                it++;
            }
        }
        print_vector(v1);
    }
}

以上就是本篇文章的所有内容,在此感谢大家的观看!这里是店小二呀C++笔记,希望对你在学习C++语言旅途中有所帮助!

相关文章
|
2月前
|
存储 程序员 C++
C++常用基础知识—STL库(2)
C++常用基础知识—STL库(2)
71 5
|
2月前
|
存储 C++ 索引
【C++打怪之路Lv9】-- vector
【C++打怪之路Lv9】-- vector
23 1
|
2月前
|
存储 自然语言处理 程序员
C++常用基础知识—STL库(1)
C++常用基础知识—STL库(1)
59 1
|
2月前
|
编译器 C++
【C++】—— vector模拟实现
【C++】—— vector模拟实现
|
2月前
|
算法 数据处理 C++
c++ STL划分算法;partition()、partition_copy()、stable_partition()、partition_point()详解
这些算法是C++ STL中处理和组织数据的强大工具,能够高效地实现复杂的数据处理逻辑。理解它们的差异和应用场景,将有助于编写更加高效和清晰的C++代码。
25 0
|
2月前
|
算法 C++ 容器
C++之打造my vector篇(下)
C++之打造my vector篇(下)
29 0
|
2月前
|
存储 编译器 C++
C++之打造my vector篇(上)
C++之打造my vector篇(上)
29 0
|
6天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
21 2
|
12天前
|
存储 编译器 C++
【c++】类和对象(下)(取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象)
本文介绍了C++中类和对象的高级特性,包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项,帮助读者深入了解C++面向对象编程的核心机制。
40 5
|
18天前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
48 4