C++STL---Vector、List所要掌握的基本知识

这篇具有很好参考价值的文章主要介绍了C++STL---Vector、List所要掌握的基本知识。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

绪论​
拼着一切代价,奔你的前程。 ——巴尔扎克;本章主要围绕vector和list的使用,以及容器底层迭代器失效问题,同时会有对原码的分析和模拟实现其底层类函数。​​​​C++STL---Vector、List所要掌握的基本知识,C++,c++,list,java话不多说安全带系好,发车啦(建议电脑观看)。

附:红色,部分为重点部分;蓝颜色为需要记忆的部分(不是死记硬背哈,多敲);黑色加粗或者其余颜色为次重点;黑色为描述需要


1.Vector

vector 重要成员函数 具体有
构造函数 vetor()
析构函数 ~vector()
迭代器类函数 begin()、end()、rbegin()、rend()、…
容量类函数 resize()、size()、capacity()、reserve()、…
元素访问类函数 operator[]、front()、back()、…
修改类函数 push_back()、pop_back()、inser()、erase()、clear()、…
非成员函数 swap()、relational operator()

——————————————

C++STL---Vector、List所要掌握的基本知识,C++,c++,list,javaVector就像一个动态的数组也就是顺序表(有些时候可以想象成常规数组),也就是在写好的类中进行一定的函数操作,其中函数操作也就是上面所写。


1.1构造函数

函数作用 函数原型
rang(迭代器) template <class InputIterator>vector (InputIterator first, InputIterator last,const allocator_type& alloc = allocator_type());
default(无参的全缺省的) explicit vector (const allocator_type& alloc = allocator_type());
fill(初始化vector为n个value值) explicit vector (size_type n, const value_type& val = value_type(),const allocator_type& alloc = allocator_type());
copy(拷贝构造) vector (const vector& x);
附:其中的const allocator_type& alloc = allocator_type())为空间配置器,这里提供了可以修改的缺省值,当你可以修改使用自己的内存池,基本不用修改STL内部提供的内存池
//初始化vector的方法
vector<int> v;//缺省
vector<int> v1(10,0);//初始化0个10
vector<int> v2(v1.begin(),v1.end());//迭代器从begin到end初始化
vector<int> v3(v2);//拷贝构造

1.2析构函数

在使用中不用去管因为其会自动执行释放构造函数所申请的空间


1.3迭代器类函数

知识点:

1.3.1begin()、end()、rbegin()、rend()

此处begin、end和string中的差不多用来指向结构中的数据,begin指向vector的首元素(类似于数组的首元素)、end指向的是数组最后一个元素的下一个位置,相反的rbegin指向的是数组的最后一个元素,而rend指向的是第一个元素的前一个位置C++STL---Vector、List所要掌握的基本知识,C++,c++,list,java
其中可以发现begin指向vector内的数据,而end则不会指向vector内

练习使用:

	vector<int> v(10, 1);
	v.push_back(2);
	vector<int>::iterator it = v.begin();//指向vector首元素的1
	while (it != v.end())
	{
		cout << *it << ' ';
		it++;
	}
	//正向打印出所有元素:1 1 1 1 1 1 1 1 1 1 2 类似于指针
	cout << endl;
	vector<int>::reverse_iterator rit = v.rbegin();
	while (rit != v.rend())
	{
		cout << *rit << ' ';
		rit++;//注意此处仍然是++而不是--
	}
	//反向的打印出所有元素:2 1 1 1 1 1 1 1 1 1 1  类似于指针
	

附:cbegin、cend、crbeing、crend 是针对于const类型的,用法一样就不展开讲了。

1.4容量类函数

知识点:

1.4.1size()

函数原型:size_type size() const;
功能:查看vector中有几个元素。

vector<int> v(10,1);
v.size();//返回10

1.4.2capacity()

函数原型:size_type capacity() const;
功能:查看vector的capacity。

vector<int> v(10,1);
v.capacity();//在VS2019IDE环境下每次扩容1.5倍 1 ~ 2 ~ 3 ~ 6 ~ 9 ~ 13 ....

1.4.3reserve()

函数原型:void reserve (size_type n);
功能:设置vector的capacity,可提前把capacity设置好避免不断动态扩容的消耗

1.4.4resize()

函数原型:void resize (size_type n, value_type val = value_type());
改变vector的size(size决定了vector容器中的元素个数)

一般来说capacity申请扩展后都不会轻易的缩回

1.4.5empty()

函数原型:bool empty() const;
功能:查看vector内是否有数据,若返回true表示size == 0,否则放回false;

1.4.6shrink_to_fit()

函数原型:void shrink_to_fit();
功能:把capacity缩小到size大小(这条函数不一定执行最终是否执行还得看编译器他是无约束力的(non-binding))

1.5元素访问类函数

知识点:

1.5.1operator[]

函数原型
reference operator[] (size_type n);
const_reference operator[] (size_type n) const;

功能:像数组一样来访问vector中的元素
如:第一个元素v[0]

1.5.2at()

函数原型
reference at (size_type n);
const_reference at (size_type n) const;

功能:访问vector中的元素,但一般来说更多的用operator[]
如:v.at(0);访问第一个元素

1.5.3front()、back()

front函数原型 back函数原型
reference front(); reference back();
const_reference front() const reference back();

front的功能:找到vector中第一个元素并返回
如:vector<int> v(10,1); v.fornt();//指向向首元素1
back的功能:同理就是找到vector的最后一个元素
如: vector<int> v(10,1); v.back();//指向向最后一个元素1


写到这我觉得没必要再写了(有点浪费时间),对于这些函数可以自行查资料,里面有解释以及函数原型!c++官网,下面我将只写函数的用处,但仍然会把一些细节给写出来!


1.6修改类函数

作用 具体函数
尾插 push_back()
尾删 pop_back()
清除数据 clear()
将新的内容覆盖老的内容 assign()
在某个位置删除数据 erase()
在某处插入数据 insert()
交换(直接交换两个对象所指向的地址) swap()

附:对于容器中我们若想在指定位置插入的话其实他并没有find函数来找到所对应的任意位置,对此在c++库中的算法库中其实有一个通用的find()查找函数
函数原型为:
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);

用法如下:
vector<int> v;//在其中存储着1 2 3 4 5 6 7 find(v.begin(),v.end(),3);//传进迭代器区间,在其中找3,最后返回对应迭代器
这样就能找到容器中的数据并且进行一定的操作。


非成员函数
vector比较重载函数:relational operators
交换函数(用处是当两个是vector要进行交换时,去调用vector修改类中的swap,他是std交换函数的重载类):swap()

对于vector来说,还有个比较重要的点:

vector迭代器失效问题

在vector使用中可能会出现两种迭代器失效的情况:

  1. 当插入数据后的迭代器失效问题:因为在插入数据的情况下,有可能会发生异地扩容,当发生异地时就会导致原本迭代器所指向的位置为一个野指针也就是所说的迭代器失效,所以我们要注意的是迭代器在插入数据后要给迭代器重新赋值,并且在模拟实现插入函数中我们可能会扩容此处也要记得防止迭代器失效而记录迭代器位置,并作出一定的改变
        iterator insert(iterator pos, const T& x)
        {
            assert(pos <= _finish);
            assert(pos >= _start);

            if (_finish == _endofstorage)
            {
                size_t n = pos - _start;//记录相对位置防止迭代器在扩容后失效
                reserve(capacity() == 0 ? 4 : capacity() * 2);
                pos = _start + n;
            }
            iterator it = _finish;
            while (it > pos) 
            {
                *it = *(it - 1);
                it--;
            }
            *it = x;
            _finish++;

            return _start;
        }
  1. 当删除数据时我们要注意的是,他可能也会有迭代器失效的问题,因为在VS2019IDE下规定当一个迭代器所指向的位置被删除后,该迭代器就已经失效了,我们不能再次的去使用若使用就会报错,而在CentOs7 g++下迭代器会指向物理下的下一个位置(如:1234 删除2后3覆盖了2的位置迭代器就会指向4),此处解决的方法为:更新迭代器让它接收erase的返回值,在c++中规定了erase删除后返回迭代器指向被删除数据的下一个位置,这样才能正确的删除数据, 如:it = erase(it)//删除后需要接收返回的迭代器

vector深浅拷贝问题

当有异地扩容的时候,我们需要去将数据进行拷贝,此处如果是内置类型的话直接进行拷贝然后释放就行了,而对于像string类这种有深浅拷贝问题的就需要注意,我们若用memcpy直接进行的拷贝就会出深浅拷贝问题,对此我们在reserve扩容函数中就需要注意改变写法具体如下。

        void reserve(size_t n)
        {
            if (n  > capacity())
            {
                T* tmp = new T[n];
                size_t sz = size();
                if (_start) 
                {
                    //memcpy(tmp, _start, sz * sizeof(T)); 此处对于自定义类型来说是一个浅拷贝了
 
                    for(size_t i = 0; i < size();i++)
                    {
                        tmp[i] = _start[i];//逐个元素的进行赋值操作就能避免
                    }
                    delete[] _start;
                }
                _start = tmp;
                _finish = _start + sz;//这里不用size()因为这样会导致为nullptr , 
                _endofstorage = _start + n;
            }
        }

vector反向迭代器的实现

对于vector反向迭代器来说,我们不能像正向一样的直接用一个指针指向start,他们需要从后往前来走(也就表示当reverse_iterartor ++ 时并不是往前走的而是往后的),这样我们就需要重新分装一个反向迭代器的类,并且对操作符++、–重载改变其原理。对此在一个类中我们还需要去实现一些其他的操作符,具体如下:

    template<class iterator>
    class reverse_iterator
    {
        typedef reverse_iterator<iterator> Self;

        reverse_iterator(iterator t)
            :it(t)
        {}
        Self& operator++()
        {
            it--;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp (it);
            it--;
            return tmp;
        }
        Self& operator--()
        {
            it++;
            return *this;
        }
        Self operator--(int)
        {
            reverse_iterator tmp = it;
            it++;
            return tmp;
        }

        Self& operator*()
        {
            reverse_iterator tmp = it;
            return *(--tmp);
        }

  

        bool operator!=(const Self& t)
        {
            return it != t.it;
        }

        bool operator==(const Self& t)
        {
            return it == t.it;
        }

    private:
        iterator it;
    };

模拟实现Vector:

#pragma once
#include<iostream>
#include<stdio.h>
#include<assert.h>

using namespace std;

namespace bit
{
    template<class T>
    class vector
    {
    public:
        // Vector的迭代器是一个原生指针
        typedef T* iterator;

        typedef const T* const_iterator;

        typedef reverse_iterator<iterator> reverse_iterator;


        reverse_iterator rbegin()
        {
            return reverse_iterator(end());
        }

        reverse_iterator rend()
        {
            return  reverse_iterator(begin());
        }

        iterator begin() 
        {
            return _start;
        }

        iterator end() 
        {
            return _finish;
        }

        const_iterator cbegin() const
        {
            return _start;
        }

        const_iterator cend() const
        {
            return _finish;
        }

        // construct and destroy
        // 
        //对于直接的构造不做如何处理
        vector()
        {}

        vector(size_t n, const T& value = T())
        {
            reserve(n);
            while (n--) {
                push_back(value);
            }
        }

        vector(int n, const T& value = T())
        {
            reserve(n);
            while (n--) {
                push_back(value);
            }
        }

        template<class InputIterator>
        vector(InputIterator first, InputIterator last)
        {
            assert(first && last);
            while(first != last)
            {
                push_back(*first);
                first++;
            }
        }
        //现代写法:
        vector(const vector<T>& v)
        {
            vector<T> tmp(v.cbegin(),v.cend());

            swap(tmp);
        }
        //传统写法:
        //vector(const vector<T>& v)
        //{
        //    //开辟一个空间
        //    reserve(v.capacity());
        //    //把数据放进去
        //    for (auto& e : v)
        //    {
        //        push_back(e);
        //    }
        //}

        vector<T>& operator=(vector<T> v)
        {
            swap(v);
            return *this;
        }
        //void operator++(int)
        //{
        //    swap(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;
        }

        void reserve(size_t n)
        {
            if (n  > capacity())
            {
                T* tmp = new T[n];
                size_t sz = size();
                if (_start) 
                {
                    //memcpy(tmp, _start, sz * sizeof(T)); 此处对于自定义类型来说是一个浅拷贝了
 
                    for(size_t i = 0; i < size();i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                }
                _start = tmp;
                _finish = _start + sz;//这里不用size()因为这样会导致为nullptr , 
                _endofstorage = _start + n;
            }
        }

        void resize(size_t n, const T& value = T())
        {
            if (n < capacity())
            {
                _finish = _start + n;
            }
            else {
                reserve(n);
                while (_finish < _start + n)
                {
                    *_finish = value;
                    ++_finish;
                }
            }
        }



        /access///

        T& operator[](size_t pos)
        {
            assert(pos < size());

            return _start[pos];
        }

        const T& operator[](size_t pos)const
        {
            assert(pos < size());

            return _start[pos];
        }



        /modify/

        void push_back(const T& x)
        {
   /*         if (_finish == _endofstorage)
            {
                int cp = capacity() == 0 ? 4 : capacity() * 2;
                reserve(cp);
            }
            *_finish = x;
            _finish++;*/
            insert(end(), x);
        }

        void pop_back()
        {
            _finish--;
        }

        void swap(vector<T>& v)
        {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endofstorage, v._endofstorage);
        }

        iterator insert(iterator pos, const T& x)
        {
            assert(pos <= _finish);
            assert(pos >= _start);

            if (_finish == _endofstorage)
            {
                size_t n = pos - _start;//防止迭代器在扩容后失效
                reserve(capacity() == 0 ? 4 : capacity() * 2);
                pos = _start + n;
            }
            iterator it = _finish;
            while (it > pos) 
            {
                *it = *(it - 1);
                it--;
            }
            *it = x;
            _finish++;

  
            return _start;
        }

        iterator erase(iterator pos)
        {
            assert(pos < _finish);
            assert(pos >= _start);

            iterator it = pos + 1;
            while (it < _finish)
            {
                *(it - 1) = *it;
                it++;
            }
            
            _finish--;
            return pos;
        }
  

    private:
        //给他们初始值是为了预防
        iterator _start = nullptr; // 指向数据块的开始

        iterator _finish = nullptr; // 指向有效数据的尾

        iterator _endofstorage = nullptr; // 指向存储容量的尾

    };

    template<class iterator>
    class reverse_iterator
    {
        typedef reverse_iterator<iterator> Self;

        reverse_iterator(iterator t)
            :it(t)
        {}
        Self& operator++()
        {
            it--;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp (it);
            it--;
            return tmp;
        }
        Self& operator--()
        {
            it++;
            return *this;
        }
        Self operator--(int)
        {
            reverse_iterator tmp = it;
            it++;
            return tmp;
        }

        Self& operator*()
        {
            reverse_iterator tmp = it;
            return *(--tmp);
        }

        bool operator!=(const Self& t)
        {
            return it != t.it;
        }

        bool operator==(const Self& t)
        {
            return it == t.it;
        }

    private:
        iterator it;
    };

}



2.List

在STL的list其实就是数据结构中的带头双向循环列表(若不清楚的建议看看数据机构基础之链表)
C++STL---Vector、List所要掌握的基本知识,C++,c++,list,java

list 重要成员函数 具体有
构造函数 list()
析构函数 ~list()
迭代器类函数 begin()、end()、rbegin()、rend()、…
容量类函数 size()、empty()、…
元素访问类函数 front()、back()
修改类函数 push_back()、pop_back()、push_front()、inser()、erase()、clear()、…
操作类函数 sort() 、 reverse() 、remove() 、…
非成员函数 swap()、relational operator()

同样的在list中也不会去详细的简述函数(这些都是熟能生巧的多去查文档),会在后面写道一些细节内容以及函数的功能

2.1构造函数、析构函数

构造函数( (constructor)) 作用
list (size_type n, const value_type& val = value_type()) 构造的list中包含n个值为val的元素
list() 构造空的list
list (const list& x) 拷贝构造函数
list (InputIterator first, InputIterator last) 用[first, last)区间中的元素构造list

析构函数不用自己调用,其内部主要包括把所借的内存归还给操作系统操作

2.2迭代器类函数

具体函数 作用
begin() 返回第一个元素的迭代器
end() 返回最后一个元素下一个位置的迭代器
rbegin() 返回第一个元素的reverse_iterator,即end位置
rend 返回最后一个元素下一个位置的reverse_iterator,即begin位置
注意点 在反向迭代器中++,是表示往前走 而不是往后 ; 同理的-- 则表示往后走

2.3容量类函数

具体函数 作用
empty() 检测list是否为空,是返回true,否则返回false
size() 返回list中有效节点的个数

2.4元素访问类函数

具体函数 作用
front() 返回list的第一个节点中值的引用
back() 返回list的最后一个节点中值的引用

2.5修改类函数

具体函数 作用
push_back(const value_type& val) 在list尾部插入值为val的元素
pop_back() 删除list中最后一个元素
push_front(const value_type& val) 在list首元素前插入值为val的元素
pop_front() 删除list中第一个元素
iterator inser(iterator position, const value_type& val) 在pos位置(此处是迭代器)处插入值为val的元素,还能插入一次性n个元素以及用迭代器插入一段数据
iterator erase(iterator position) 删除pos迭代器所指向位置的元素,还能一次性删除一段数据erase (iterator first, iterator last)
clear() 清空list中的有效元素
swap(list& x)) 交换两个list中的元素
void resize (size_type n, value_type val = value_type()) 提前初始化n个空间初始值默认为value_type()//整形为0…

2.5.1list 删除操作时的迭代器失效问题:

list在插入数据时并不会迭代器失效,而在删除时因为当前位置的迭代器所指向的地址空间已经被释放,而形成了迭代器失效。
所以为避免这种情况删除的实现会返回一个迭代器(也就是被删除数据的下一个位置)并且我们需要用接收这个迭代器才能解决失效问题(例:iterator it = l.erase(l.begin()))
通过上面的分析我们能知道当list删除数据后其原本的迭代器会指向被删除的数据的下一个数据,并且返回该位置!对此来实现list的删除:

       iterator erase(iterator pos)
        {
            Node* cur = pos._Node;
            Node* prev = cur->_Prev;
            Node* next = cur->_Next;//一开始记录删除数据的下一个位置

            prev->_Next = next;
            next->_Prev = prev;

            _size--;
            return iterator(next);//返回next
        }

2.6操作类函数

具体函数 作用
void splice (iterator position, list& x) 拼接两个list,还能x指定中的i位置的一个元素拼接,或者是用迭代器确定区域(first,last]进行拼接
remove(valua) 删除list中所有等于value值的元素
template <class Predicate> remove_if(Predicate pred) 删除所有满足pred仿函数(也可能是函数指针)的元素
unique() 删除重复的值
merge(list& x) 拼接两个list,他有第二个参数为仿函数(或函数指针)
sort() 对list中的数据进行排序,默认为升序,可以改变传递仿函数来自定义Compare比较函数(方法)
reverse() 逆序把list中的数据倒过来

2.7list的实现

#pragma once

#include<iostream>
using namespace std;


namespace bite
{
    // List的节点类
    template<class T>
    struct ListNode
    {
        ListNode(const T& val = T())
            :_val(val)
            ,_Prev(nullptr)
            ,_Next(nullptr)
        {}

        ListNode<T>* _Prev;
        ListNode<T>* _Next;
        T _val;
    };

    //List的迭代器类
    template<class T, class Ref, class Ptr>
    struct ListIterator
    {
        typedef ListNode<T> Node;
        typedef ListIterator<T, Ref, Ptr> Self;
    public:
        ListIterator(Node* node = nullptr) 
            :_Node(node)
        {}

        //ListIterator(const Self& l);

        T& operator*()
        {
            return _Node->_val;
        }

        Ptr operator->()
        {
            return &_Node->_val;
        }

        Self& operator++()
        {
            _Node = _Node->_Next;
            return *this;
        }
      //后置
        Self operator++(int)
        {
            Self tmp(*this);//拷贝构造
            //其中self是类型、*this是一个具体的对象
            _Node = _Node->_Next;
            return tmp;
        }
      
      //前置
        Self& operator--()
        {
            _Node = _Node->_Prev;
            return *this;
        }

        //后置需要一个类型来占位
        Self& operator--(int)
        {
            Self tmp(*this);
            _Node = _Node->_Prev;
            return tmp;
        }

        bool operator!=(const Self& l)
        {
            return _Node != l._Node;
        }

        bool operator==(const Self& l)
        {
            return _Node == l._Node;
        }

        Node* _Node;
    };

    template<class T, class Ref, class Ptr>
    struct RIterator
    {
        typedef ListNode<T> Node;
        typedef RIterator<T, Ref, Ptr> Self;
    public:
          RIterator(Node* node = nullptr)
            :_Node(node)
          {}

        //ListIterator(const Self& l);

        T& operator*()
        {
            return _Node->_val;
        }

        Ptr operator->()
        {
            return &_Node->_val;
        }

        Self& operator++()
        {
            _Node = _Node->_Prev;
            return *this;
        }
        //后置
        Self operator++(int)
        {
            Self tmp(*this);//拷贝构造
            //其中self是类型、*this是一个具体的对象
            _Node = _Node->_Prev;
            return tmp;
        }

        //前置
        Self& operator--()
        {
            _Node = _Node->_Next;
            return *this;
        }

        //后置需要一个类型来占位
        Self& operator--(int)
        {
            Self tmp(*this);
            _Node = _Node->_Next;
            return tmp;
        }

        bool operator!=(const Self& l)
        {
            return _Node != l._Node;
        }

        bool operator==(const Self& l)
        {
            return _Node == l._Node;
        }

        Node* _Node;
    };

    //list类
    template<class T>
    class list
    {
    public:
        typedef ListNode<T> Node;

        typedef ListIterator<T, T&, T*> iterator;//将


        typedef ListIterator<T, const T&, const T&> const_iterator;
    
        typedef RIterator<T, T&, T*> reverse_iterator;//将

    public:
        ///
        // List的构造

        void empty_init()
        {
            _Head = new Node;//头节点
            _Head->_Next = _Head;
            _Head->_Prev = _Head;
        }


        list()
        {
            empty_init();
        }

        list(int n, const T& value = T())
        {
            for(int i = 0; i<n;i++)
            {
                push_back(value);
            }
        }

        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            Iterator it = first;
            while (it != last)
            {
                push_back(*it);
                ++it;
            }
        }

        void swap(list<T>& l)
        {
            std::swap(_Head, l._Head);
            std::swap(_size, l._size);
        }

        list(const list<T>& l)
        {
            empty_init();
            for (auto nd : l)
            {
                push_back(nd);
            }
        }

        list<T>& operator=(list<T> l)
        {
            swap(l);

            return *this;
        }

        ~list()
        {
            clear();//将申请的空间返还
            delete _Head;
            _Head = nullptr;
        }

        ///
        // List Iterator
        iterator begin()
        {
            //return iterator(_Head->_Next);
            return _Head->_Next;

        }
        iterator end()
        {
            //return iterator(_Head);
            return _Head;
        }

        const_iterator begin()const
        {
            return _Head->_Next;
        }

        const_iterator end()const
        {
            return _Head;
        }
        
        reverse_iterator rbegin()
        {
            return reverse_iterator(_Head->_Prev);
        }

        reverse_iterator rend()
        {
            return reverse_iterator(_Head);
        }

        // List Capacity
        size_t size()const
        {
            return _size;
        }

        bool empty()const
        {
            return _size == 0;
        }

         List Access
        T& front()
        {
            return _Head->_Next->_val;
        }

        const T& front()const
        {
            return _Head->_Next->_val;
        }
        //
        T& back()
        {
            return _Head->_Prev->_val;
        }
        //
        const T& back()const
        {
            return _Head->_Prev->_val;
        }
        
        // List Modify
        void push_back(const T& val)
        { 
            //Node* tail = _Head->_Prev;
            //Node* newnode = new Node(val);

            //tail->_Next = newnode;
            //newnode->_Prev = tail;

            //_Head->_Prev = newnode;
            //newnode->_Next = _Head;

            //_size++;
            insert(end(), val); 
        }


        void pop_back() 
        {
 /*           Node* tail = _Head->_Prev;

            tail->_Prev->_Next = _Head;
            _Head->_Prev = tail->_Prev;

            delete tail;

            _size--;*/
            erase(--end()); 
        }

        void push_front(const T& val) 
        { 
            //Node* head = _Head->_Next;
            //Node* newnode = new Node(val);

            //head->_Prev = newnode;
            //newnode->_Next = head;

            //_Head->_Next = newnode;
            //head->_Prev = _Head;

            //_size++;
            insert(begin(), val); 
        }

        void pop_front()
        { 
   /*         Node* head = _Head->_Next;

            head->_Next->_Prev = _Head;
            _Head->_Next = head->_Next;
            delete head;
            _size--;*/
            erase(begin());
        }
         在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            Node* cur = pos._Node;
            Node* newnode = new Node(val);
            Node* prev = cur->_Prev;

            prev->_Next = newnode;
            newnode->_Prev = prev;

            newnode->_Next = cur;
            cur->_Prev = newnode;
            
            _size++;
            return iterator(newnode);
        }
         删除pos位置的节点,返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            Node* cur = pos._Node;
            Node* prev = cur->_Prev;
            Node* next = cur->_Next;

            prev->_Next = next;
            next->_Prev = prev;

            _size--;
            return iterator(next);
        }
        void clear()
        {
            iterator it = begin();
            while(it != end())
            {
                it = erase(it);
            }
            //for(auto it : )
            _size = 0;
        }
    private:
        Node* _Head;
        size_t _size;
    };
}

本章完。预知后事如何,暂听下回分解。

如果有任何问题欢迎讨论哈!

如果觉得这篇文章对你有所帮助的话点点赞吧!

持续更新大量C++细致内容,早关注不迷路。

文章来源地址https://www.toymoban.com/news/detail-718382.html

到了这里,关于C++STL---Vector、List所要掌握的基本知识的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • STL list基本用法

    list的底层实际是双向链表结构 构造函数 说明 list() 无参构造 list (size_type n, const value_type val = value_type()) 构造的list中包含n个值为val的元素 list (const list x) 拷贝构造函数 list (InputIterator first, InputIterator last) 用[first, last)区间中的元素构造list 构造函数和前面的容器用法相同 赋值

    2024年02月11日
    浏览(40)
  • 【C++】STL---list基本用法介绍

    个人主页:平行线也会相交💪 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 平行线也会相交 原创 收录于专栏【C++之路】💌 本专栏旨在记录C++的学习路线,望对大家有所帮助🙇‍ 希望我们一起努力、成长,共同进步。🍓 list 是STL中的一种 容器 ,底层其实就是一个 双向链

    2024年02月16日
    浏览(43)
  • 【C++ STL】 list 基础知识

    本篇将学习 list 的基础知识 🕺作者: 主页

    2024年02月05日
    浏览(53)
  • 【C++STL基础入门】list基本使用

    STL(Standard Template Library)是C++标准库的一个重要组成部分,提供了一套丰富的数据结构和算法,可以大大简化C++程序的开发过程。其中,list容器是STL提供的一种双向链表实现的数据结构,具有高效的插入和删除操作,适用于需要频繁插入和删除元素的场景。本文将介绍list容

    2024年02月07日
    浏览(58)
  • 掌握Python的X篇_15_list容器的基本使用

    list的应用很广泛,当需要动态的增减容器中的元素,都是可以使用到的。 容器变量是一种特殊的变量,容器变量中,可以存储多个其它变量 我们可以把list比作书柜,而之前所学的普通变量类型( 比如数字 ) 是书 list变量也是一种变量,因此其变量名的要求与之前所学习的普

    2024年02月15日
    浏览(27)
  • 【002JavaScript 类继承】基本继承、调用父类方法和混入模式等方面的知识。掌握类继承的概念和技巧,提升代码的灵活性和可维护性。

    在 JavaScript 中,类继承是实现代码复用和扩展的重要概念。通过继承,我们可以基于现有类创建新类,并继承父类的属性和方法。本文将详细介绍 JavaScript 类继承的各个方面和技巧。 使用 extends 可以实现基本的类继承。 } class Dog extends Animal { bark() { console.log( ${this.nam

    2024年02月08日
    浏览(57)
  • 探索MATLAB世界:掌握基础知识与实用技能(1. MATLAB环境与基本操作 2. 数据类型与变量 3. 条件与循环,1. 数据分析与统计 2. 图像处理与计算机视觉 3. 信号处理与控制系统)

    欢迎阅读本篇博客,我们将深入探讨MATLAB语言的基础知识与实用技能,旨在帮助初学者、初中级MATLAB程序员以及在校大学生系统地掌握这门强大的科学计算与数据可视化工具。 一、MATLAB的基础知识 1. MATLAB环境与基本操作 2. 数据类型与变量 3. 条件与循环 二、MATLAB的实用技能

    2024年03月12日
    浏览(57)
  • 【List】List集合有序测试案例:ArrayList,LinkedList,Vector(123)

    List是有序、可重复的容器。 有序: List中每个元素都有索引标记。可以根据元素的索引标记(在List中的位置)访问 元素,从而精确控制这些元素。 可重复: List允许加入重复的元素。更确切地讲,List通常允许满足 e1.equals(e2) 的元素重复加入容器。 List接口常用的实现类有3个:

    2024年02月11日
    浏览(44)
  • 浅谈C++|STL之list+forward_list篇

    功能 :将数据进行链式存储 链表 (list)是一种物理存储单元上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成:链表由—系列 结点 组成 结点的组成:一个是存储数据元素的 数据域 ,另一个是存储下一个结点地址的 指针域 STL中的链表是一个

    2024年02月08日
    浏览(33)
  • 哈希表HashMap(基于vector和list)

    C++数据结构与算法实现(目录) 1 什么是HashMap? 我们这里要实现的HashMap接口不会超过标准库的版本(是一个子集)。 HashMap是一种键值对容器( 关联容器 ),又叫 字典 。 和其他容易一样,它可以对存储的元素进行 增删改查 操作。 它之所以叫关联容器,是因为它的每个元

    2024年02月10日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包