STL容器之vector

已于 2024-02-23 16:57:21 修改
阅读量642 收藏 7
点赞数 23
分类专栏： c++ 文章标签： c++ 开发语言
于 2024-02-22 23:38:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33093885/article/details/136245234
版权

一、简单认识vector

​ 1.vector是一种有序顺序表模板；2.vector插入或者删除都存在迭代器失效问题；

​ 与string的区别：

​ 1.相较于string的设计简单了不少，且vector是一个模板；2.vector<char>并不能替代string，因为string有’\0’结尾，自动实现，而vector可以’\0’结尾，但不能自动实现;3.string的接口更加丰富，如：+=，比较大小的设计更有意义，find等字符函数的用途；

template < class T, class Alloc = allocator<T> > class vector; // generic template

​ stl的所有容器都使用了空间配置器(内存池)，

二、vector的使用

1.成员类型在这里插入图片描述

2.默认成员函数

2.1构造函数

//1.无参
explicit vector (const allocator_type& alloc = allocator_type());
//2.n个T类型的值
explicit vector (size_type n, const value_type& val = value_type(),const allocator_type& alloc = allocator_type());
//3.用迭代器模板初始化，函数模板隐式实例化。可以使用自己类型的迭代器，也可以使用其他类型的。
//因为指针是天然的迭代器，所以也支持。
template <class InputIterator>
vector (InputIterator first, InputIterator last,const allocator_type& alloc = allocator_type());

3.迭代器

​ 与string一样。

iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;

4.堆空间操作

//1
size_type size() const;
//2
void resize (size_type n, value_type val = value_type());
//3
void reserve (size_type n);
void test()
{
    vector<int> v;
    //v.reserve(10 * sizeof(int));//使用reserve主要是一次性开部分空间，为了减少扩容消耗。
   	v.resize(10);//这样就size不为零。
    for (size_t i = 0; i < 10; ++i)
    {
        v[i] = i;//operato[]r会使用断言，检查pos位置是否小于size。size为0，一定报错。at是抛异常。
    }
}

5.元素访问

//1
reference operator[] (size_type n);
const_reference operator[] (size_type n) const;
//2
reference at (size_type n);
const_reference at (size_type n) const;
//3
reference front();
const_reference front() const;
//4
reference back();
const_reference back() const;
//5
value_type* data() noexcept;
const value_type* data() const noexcept;

6.修改数据

//1.尾插
void push_back (const value_type& val);
//2.尾删
void pop_back();
//3.任意位置插入
iterator insert (iterator position, const value_type& val);//迭代器位置往后一个值
void insert (iterator position, size_type n, const value_type& val);//迭代器往后n个值
template <class InputIterator>
void insert (iterator position, InputIterator first, InputIterator last);
//4.任意位置删除
//设计迭代器失效的问题
iterator erase (iterator position);//删除某个位置
iterator erase (iterator first, iterator last);//删除某段区间
//5.swap
void swap (vector& x);
//6.清理数据
void clear()
//7.重新赋值
template <class InputIterator>
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);

三、算法algorithm

​ 使用迭代器实现不同容器的复用。

#include<algorithm>
//1.sort
template <class RandomAccessIterator>
void sort (RandomAccessIterator first, RandomAccessIterator last);
//2.swap
template <class T> void swap (T& a, T& b);
//3.find
template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val);
An iterator to the first element in the range that compares equal to val.
If no elements match, the function returns last.

补充：1.对于指针变量来说，指针变量存放的是地址，使用解引用底层会到存放的地址处进行访问，对于空指针和野指针，进行访问就会导致程序崩溃。2.一级指针变量的地址被设置成了只能存放在二级指针变量的空间。3.对于获得使用权的空间，使用的是不同的类型来划定空间的范围来进行访问，如：int*的指针变量，每次可访问4个字节，对它的++就被识别成了按照4个字节进行移动。

四、vector的模拟实现

补充：

​ 1.c++初始化列表出现以后对内置类型进行了升级，支持了默认构造；2.注意扩容逻辑对于自定义类型不能使用浅拷贝memcpy，可以使用赋值运算符重载；3.插入删除时会存在迭代器失效问题，所以没吃都要重置迭代器；4.对于拷贝构造和赋值重载可以复用resize和reserve，使用前必须在初始化列表进行初始化，底层会实现对成员变量的修改，要注意的是reserve后要clear数据，然后必须用尾插，resize直接使用赋值，或者clear之后尾插；5.reserve还有finish_没有初始化，resize全部初始化了；6.使用迭代器区间构造，类模板里面定义函数模板。

1.成员变量

public:
    typedef T value_type;
	typedef value_type* iterator;
protected:
  	iterator start;
  	iterator finish;
  	iterator end_of_storage;
//并不是以下的,所以需要了解一下构造函数和插入接口或者扩容逻辑
	iterator a_;
	size_t size_;
	size_t capacity;

2.默认成员函数

//1.默认构造
//1.1
vector() : start_(nullptr), finish_(nullptr), end_of_storage_(nullptr) {}
//1.2
vector(size_t n, const T &val = T()) : start_(nullptr), finish_(nullptr), end_of_storage_(nullptr)
{
    resize(n, val);
}
//1.3
template <class InputIteartor>//可能会和1.2冲突，vector<int>v(10u,5),才会识别成1.2
vector(InputIteartor first, InputIteartor last): start_(nullptr), finish_(nullptr), end_of_storage_(nullptr)
{
    while (first != last)
    {
        push_back(*first);
        first++;
    }
}
//2.拷贝构造
//2.1传统方式
vector(const vector<T> &v) : start_(nullptr), finish_(nullptr), end_of_storage_(nullptr)
{
    start_ = new T[v.capacity()];
    for (size_t i = 0; i < v.size(); i++)
    {
        start_[i] = v.start_[i];
    }
    finish_ = start_ + v.size();
    end_of_storage_ = start_ + v.capacity();
}
//2.2复用reserve，resize
vector(const vector<T> &v) : start_(nullptr), finish_(nullptr), end_of_storage_(nullptr)
{
    // reserve(v.capacity());
    // for (auto e : v)
    // {
    //     push_back(e);
    // }
    resize(v.size());
    for (size_t i = 0; i < v.size(); i++)
    {
        start_[i] = v.start_[i];
    }

}
//2.3现代方式
//3赋值重载
//3.1复用resize reserve
vector<T> &operator=(const vector<T> &v)
{
    resize(v.size());//成员变量全部初始化好
    for (size_t i = 0; i < v.size(); i++)
    {
        start_[i] = v.start_[i];//转换为调用自定义类型的赋值运算符重载
    }
    return *this;
    reserve(v.capacity());//finish_没初始化
    clear();
    for (auto e : v)
    {
        push_back(e);//会初始化finish_
    }
    return *this;
}
//3.2现代方式
vector<T> &operator=(vector<T> v)
{
    std::swap(start_, v.start_);
    std::swap(finish_, v.finish_);
    std::swap(end_of_storage_, v.end_of_storage_);
    return *this;
}
//3.3传统方式
vector<T> &operator=(const vector<T> &v)
{
    reserve(v.capacity());
    clear();
    //memcpy(start_, v.start_, sizeof(T) * v.size());//对于自定义类型memcpy会浅拷贝，会产生野指针问题，和内存泄漏。
    for (auto e:v)
    {
        push_back(e);
    }
    return *this;
}
~vector()
{
    if (start_)
    {
        delete[] start_;
        start_ = finish_ = end_of_storage_ = nullptr;
    }
}

3.插入接口

void push_back(const T &val)
{
    // if (finish_ == end_of_storage_)
    // {
    //     size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
    //     reserve(newcapacity);
    // }
    // *finish_ = val;
    // ++finish_;
    insert(end(), val);
}
// 注意迭代器失效的问题：1.野指针失效，内外迭代器都会因为异地扩容释放旧空间，导致pos失效了。
iterator insert(iterator pos, const T &val)
{
    assert(pos >= start_ && pos <= finish_);
    if (finish_ == end_of_storage_)
    {
        size_t len = pos - start_;
        size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
        reserve(newcapacity);
        pos = start_ + len;
    }
    iterator end = finish_ - 1;
    while (end >= pos)
    {
        *(end + 1) = *end;
        end--;
    }
    *pos = val;
    finish_++;
    return pos;
}

4.删除接口

//迭代器失效，最后一个位置的数据一般都不会挪动，再次访问最后一个位置就会出现问题。
//vs对迭代器进行了强制检查，访问程序直接就崩了；g++没有强制检查。
//为具有平台移植性，对于失效的迭代器不能访问。
iterator erase(iterator pos)
{
    assert(pos >= start_ && pos < finish_);
    iterator it = pos + 1;
    while (it < finish_)
    {
        *(it - 1) = *it;
        ++it;
    }
    --finish_;
    return pos;
}
void pop_back()
{
    erase(end() - 1);
}

5.对于空间的操作

size_t capacity() const
{
    return end_of_storage_ - start_;
}
size_t size() const
{
    return finish_ - start_;
}
//对于自定义类型要注意memcpy会浅拷贝，如：vector<string>在扩容时使用了memcpy,
//对sting对象进行了浅拷贝
void reserve(size_t n)
{
    if (n > capacity())
    {
        size_t oldsize = size();
        iterator tmp = new T[n];
        if (start_)
        {
            // memcpy(tmp, start_, oldsize * sizeof(T));//扩容可能浅拷贝
            for (size_t i = 0; i < oldsize; i++)
            {
                tmp[i] = start_[i];
            }
            delete[] start_;
        }
        // 问题
        //  start_ = tmp;
        //  finish_ = start_ + size(); // 调用size时，函数内的start_已经变了，不是0。
        //  end_of_storage_ = start_ + n;
        // 解决1
        //  finish_ = tmp + size();
        //  start_ = tmp;
        //  end_of_storage_ = start_ + n;
        // 解决2
        start_ = tmp;
        finish_ = start_ + oldsize;
        end_of_storage_ = start_ + n;
    }
}
bool empty()
{
    return size() == 0;
}
void resize(size_t n, const T &x = T())
{
    if (n < size())
    {
        finish_ = start_ + n;
    }
    else
    {
        reserve(n);
        while (finish_ != start_ + n)
        {
            *finish_ = x;
            ++finish_;
        }
    }
}
void clear()
{
    resize(0);
}

6.元素访问

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

7.迭代器

iterator begin()
{
    return start_;
}
iterator end()
{
    return finish_;
}
const_iterator begin() const
{
    return start_;
}
const_iterator end() const
{
    return finish_;
}

8.成员类型

typedef T *iterator;
typedef const T *const_iterator;
pick me long
关注
专栏目录
STL容器之vector 的下标越界是否报错
a3192048的博客
07-13 5736
今天将程序在VS2015和g++ 5.4.0下运行，发现vector越界 VS会报错，而g++正常输出。故而查看了源码，看个究竟。例：#include &lt;iostream&gt; #include &lt;vector&gt; using namespace std; int main() { vector &lt;int&gt; a; a.push_back(6...
【C++】STL容器之vector的使用及遍历
天亮就睡
03-07 1405
文章目录基本概念使用vector容量和大小vector插入和删除vector数据存取vector互换容器迭代器遍历代码解析（下面有完整代码）第一种遍历方式：第二种遍历方式：第三种遍历方式：完整代码Vector容器嵌套容器 基本概念 功能： vector数据结构和数组非常相似，也称为单端数组 能存放任意数据类型（类，结构，普通变量类型等） 和普通数组一样可以通过下标索引来进行访问 vector与普通数组区别： 不同之处在于数组是静态空间，而vector可以动态扩展 动态扩展： 并不是在原空间之后续接新空间，
C++ STL之vector容器
咸鱼势力登场
04-25 2746
vector容器的介绍 vector容器的使用 [1.vector的构造函数 2.vector的赋值操作 3.vector的容量与大小 4.vector的插入和删除 5.vector的数据存取 6.vector的互换容器 7.算法模块在vector的应用①find算法(std)②sort算法(std)]
【STL】STL容器之vector
hujingshuang
12-05 2184
在本节中介绍STL标准库类型的vector容器。实际上，STL中的vector容器就是动态大小数组。
C++ STL之vector详解
热门推荐
行码棋
01-04 7万+
本文介绍了STL的vector的常用操作以及相关的注意事项
STL容器: vector数组
qq_46785243的博客
04-14 1414
关于C++vector数组的基础学习
C++ 入门14：STL 容器之向量（vector）
LF__plus的博客
07-15 909
在前面文章的学习中，我们学习了类和对象的基础知识、构造函数、拷贝构造函数、静态成员、常量成员、运算符重载、友元函数、友元类、继承和派生类、虚函数和多态、模板以及异常处理。今天，我们将学习 C++ 标准模板库（STL）中的一种重要容器——向量（vector）。向量是一种动态数组，可以方便地进行元素的添加和删除操作。这是STL里非常常用的一种，需要好好掌握。
C++-STL容器之vector
2301_79349959的博客
02-07 1502
C++标准模板库（STL）中的是vector一种序列容器，它封装了能够存储任意类型（例如整数、字符串等）的动态大小数组。使用vector，你可以快速地在序列的末尾添加或移除元素，并且能够随机访问序列中的任何元素。下面我将详细介绍vector的特性、常用操作以及使用时的注意事项。
STL常用容器——vector容器的使用
万里顾一程的博客
10-07 917
重新指定容器的长度为num，若容器长度变长，则以elem值填充新位置；如果容器长度变短，则超出容器长度的末尾元素要被删除。vector 实现的是一个动态数组，可以动态扩展，即可以进行元素的插入和删除，在此过程中，vector 会动态调整所占用的内存空间。将v[begin(),end())区间中的元素拷贝给本身。
C++实现STL容器之Vector
04-08
C++实现STL容器之Vector
STL容器之array和vector.zip
10-07
在这个“STL容器之array和vector.zip”压缩包中，我们主要探讨两个重要的容器：`std::array`和`std::vector`。它们都是用于存储元素序列的容器，但有着不同的特性和使用场景。 `std::array`是C++11引入的一个固定...
C++(STL库)之顺序容器vector的使用
12-20
C++中的STL库是标准模板库（Standard Template Library）的简称，它是C++编程语言的一个重要组成部分，提供了丰富的容器、算法和迭代器等工具，极大地提高了开发效率。在这个库中，`vector`是一个非常常用的顺序容器...
【C++】STL容器之vector
DanteKing的博客
02-04 1342
前言 C++引入了面向对象的思想，相比于C语言，一个类能更好地对一些数据结构进行管理和操作。 在C语言中，我们使用定长数组和malloc出来的动态数组来维护一段连续的相同类型数据的集合 在C++中，基于面向对象的思想，用来管理空间上连续的同类型数据集合的类便应运而生，从本质上讲，vector类就是一个被封装了的大小可变数组的序列容器 目录 1.vector的简介 2.vector的常见接口及模拟实现     2.1 vector类对象的常见构造  &
大话C++：第15篇 友元
whccf的博客
10-09 937
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 940
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
【C++】List
m0_46676283的博客
10-08 403
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
C语言 | Leetcode C语言题解之第472题连接词
最新发布
m0_59237910的博客
10-11 365
C语言 | Leetcode C语言题解之第472题连接词
C++：图的最短路径问题
han2205277149的博客
10-04 1115
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
stl容器中vector
04-26
vector是C++标准库中的一个动态数组容器，提供了一种方便的方式来存储和操作一系列的元素。vector可以自动调整大小，可以在尾部快速插入和删除元素，并且支持随机访问。 以下是vector的一些重要特点和用法： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值