c++ 11标准模板（STL） std::vector (四）

最新推荐文章于 2024-05-11 19:00:00 发布
最新推荐文章于 2024-05-11 19:00:00 发布
阅读量985 收藏
点赞数 1
分类专栏： # std::vector 文章标签： c++ 封装动态数组的顺序容器 vector 标准库模板 元素访问
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/130456178
版权 
定义于头文件 <vector>
template<

    class T,
    class Allocator = std::allocator<T>

> class vector;		(1)
namespace pmr {

    template <class T>
    using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;

}		(2)(C++17 起)

 1) std::vector 是封装动态数组的顺序容器。

2) std::pmr::vector 是使用多态分配器的模板别名。

元素相继存储，这意味着不仅可通过迭代器，还能用指向元素的常规指针访问元素。这意味着指向 vector 元素的指针能传递给任何期待指向数组元素的指针的函数。

(C++03 起)

vector 的存储是自动管理的，按需扩张收缩。 vector 通常占用多于静态数组的空间，因为要分配更多内存以管理将来的增长。 vector 所用的方式不在每次插入元素时，而只在额外内存耗尽时重分配。分配的内存总量可用 capacity() 函数查询。额外内存可通过对 shrink_to_fit() 的调用返回给系统。 (C++11 起)

重分配通常是性能上有开销的操作。若元素数量已知，则 reserve() 函数可用于消除重分配。

vector 上的常见操作复杂度（效率）如下：

  • 随机访问——常数 O(1)
  • 在末尾插入或移除元素——均摊常数 O(1)
  • 插入或移除元素——与到 vector 结尾的距离成线性 O(n)

std::vector （对于 bool 以外的 T ）满足容器 (Container) 、具分配器容器 (AllocatorAwareContainer) 、序列容器 (SequenceContainer) 、连续容器 (ContiguousContainer) (C++17 起)及可逆容器 (ReversibleContainer) 的要求。

元素访问

访问指定的元素，同时进行越界检查

std::vector<T,Allocator>::at

reference       at( size_type pos );

const_reference at( size_type pos ) const;

 返回位于指定位置 pos 的元素的引用，有边界检查。

若 pos 不在容器范围内，则抛出 std::out_of_range 类型的异常。

参数

pos-要返回的元素的位置

返回值

到所需元素的引用。

异常

若 !(pos < size()) 则抛出 std::out_of_range

复杂度

常数。

访问指定的元素

std::vector<T,Allocator>::operator[]

reference       operator[]( size_type pos );

const_reference operator[]( size_type pos ) const;

 返回位于指定位置 pos 的元素的引用。不进行边界检查。

参数

pos-要返回的元素的位置

返回值

到所需元素的引用。

复杂度

常数。

注意

不同于 std::map::operator[] ，此运算符决不插入新元素到容器。

访问第一个元素

std::vector<T,Allocator>::front

reference front();

const_reference front() const;

 返回到容器首元素的引用。

在空容器上对 front 的调用是未定义的。

参数

（无）

返回值

到首元素的引用

复杂度

常数

注意

对于容器 c ，表达式 c.front() 等价于 *c.begin() 。

访问最后一个元素

std::vector<T,Allocator>::back

reference back();

const_reference back() const;

 返回到容器中最后一个元素的引用。

在空容器上对 back 的调用是未定义的。

参数

（无）

返回值

到最后元素的引用。

复杂度

常数。

注意

对于容器 c ，表达式 return c.back(); 等价于 { auto tmp = c.end(); --tmp; return *tmp; }

返回指向内存中数组第一个元素的指针

std::vector<T,Allocator>::data

T* data() noexcept;

(C++11 起)

const T* data() const noexcept;

(C++11 起)

 返回指向作为元素存储工作的底层数组的指针。指针满足范围 [data(); data() + size()) 始终是合法范围，即使容器为空（该情况下 data() 不可解引用）。

参数

（无）

返回值

指向底层元素存储的指针。对于非空容器，返回的指针与首元素地址比较相等。

复杂度

常数。

注意

若 size() 为 0 ，则 data() 可能或可能不返回空指针。

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <time.h>
#include <vector>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}


int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return cell;
    };


    //3) 构造拥有 count 个有值 value 的元素的容器。
    std::vector<Cell> vector1(6, generate());
    std::generate(vector1.begin(), vector1.end(), generate);
    std::cout << "vector1:  ";
    std::copy(vector1.begin(), vector1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    for (size_t index = 0 ; index < vector1.size(); index++)
    {
        Cell cell = generate();
        //返回位于指定位置 pos 的元素的引用，有边界检查。
        //若 pos 不在容器范围内，则抛出 std::out_of_range 类型的异常。
        //reference       at( size_type pos );
        vector1.at(index) = cell;
        std::cout << "vector1.at( " << index << " ) = " << cell << std::endl;
    }
    std::cout << std::endl;

    for (size_t index = 0 ; index < vector1.size(); index++)
    {
        //返回位于指定位置 pos 的元素的引用，有边界检查。
        //若 pos 不在容器范围内，则抛出 std::out_of_range 类型的异常。
        //const_reference at( size_type pos ) const;
        std::cout << "vector1.at( " << index << " ) = "
                  << vector1.at(index) << std::endl;
    }
    std::cout << std::endl;

    //3) 构造拥有 count 个有值 value 的元素的容器。
    std::vector<Cell> vector2(6, generate());
    std::generate(vector2.begin(), vector2.end(), generate);
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    for (size_t index = 0 ; index < vector2.size(); index++)
    {
        Cell cell = generate();
        //返回位于指定位置 pos 的元素的引用。不进行边界检查。
        //reference       operator[]( size_type pos );
        vector2[index] = cell;
        std::cout << "vector2[] " << index << " ] = " << cell << std::endl;
    }
    std::cout << std::endl;

    for (size_t index = 0 ; index < vector2.size(); index++)
    {
        //返回位于指定位置 pos 的元素的引用。不进行边界检查。
        //const_reference operator[]( size_type pos ) const;
        std::cout << "vector2[ " << index << " ] = "
                  << vector2[index] << std::endl;
    }
    std::cout << std::endl;

    //返回到容器首元素的引用。在空容器上对 front 的调用是未定义的。
    Cell cell = generate();
    vector1.front() = cell;
    std::cout << "vector1.front() = " << cell << std::endl;
    std::cout << "vector1.front() : " << vector1.front() << std::endl;
    std::cout << std::endl;

    //返回到容器中最后一个元素的引用。在空容器上对 back 的调用是未定义的。
    vector1.back() = cell;
    std::cout << "vector1.back()  = " << cell << std::endl;
    std::cout << "vector1.back()  : " << vector1.back() << std::endl;
    std::cout << std::endl;

    for (size_t index = 0; index < vector1.size(); index++)
    {
        //返回指向作为元素存储工作的底层数组的指针。
        //指针满足范围 [data(); data() + size()) 始终是合法范围，
        //即使容器为空（该情况下 data() 不可解引用）。
        //T* data() noexcept;
        Cell cell = generate();
        *(vector1.data() + index) = cell;
        std::cout << "vector1: " << (vector1.data() + index)
                  << " = " << cell << std::endl;
    }
    std::cout << std::endl;

    for (size_t index = 0; index < vector1.size(); index++)
    {
        //返回指向作为元素存储工作的底层数组的指针。
        //指针满足范围 [data(); data() + size()) 始终是合法范围，
        //即使容器为空（该情况下 data() 不可解引用）。
        //const T* data() const noexcept;
        std::cout << "vector1: " << (vector1.data() + index) << " : "
                  << *(vector1.data() + index) << std::endl;
    }

    return 0;
}

输出

 

繁星璀璨G
关注
专栏目录
C++11 新特性 ④ | 模板类 std::function 和标准库函数 std::bind
dvlinker的技术专栏
09-09 1万+
详细讲解模板类std::function和标准库函数std::bind。
std::vector 常用用法汇总和代码用例
小秋 AI SLAM 入门实战教程
01-11 1221
代码首先展示了如何添加、访问和删除元素，然后展示了如何遍历。最后，代码展示了如何使用。方法访问最后一个元素，并如何使用。在这段代码中，我演示了。，包括使用范围基于的。时会经常遇到的操作。
std::vector --- [ vector官方文档- C++ Reference ]
happylzs2008的专栏
11-04 617
http://www.cplusplus.com/reference/vector/vector/ C++_vector操作 https://blog.csdn.net/weixin_41743247/article/details/90635931 C++ vector用法（详解！！函数，实现） https://blog.csdn.net/msdnwolaile/article/details/52708144
STL vector<bool>中的reference(2)
roaylchen的博客
08-20 1380
原文地址: public member class std::vector::reference class reference; Reference type This embedded class is the type returned by members of non-const vector when directly accessing its
std::vector<T>内存映像
OPEN_GIS
09-26 766
存储结构内存映像 具有多余容量的std::vector的典型内存映像：
对于 std::vector<T> , 当T没有赋值运算符函数的时候，如何调用vector push_back?
hengshan的专栏
10-16 4937
这个问题是在stackoverflow发现的： http://stackoverflow.com/questions/12908398/can-placement-new-and-vectordata-be-used-to-replace-elements-in-a-vector 我是对讨论做一个整理，如下。 1.代码片段 #include   2 #include   3
std::vector<T>的reserve()和resize()
OPEN_GIS
09-27 1897
预备概念： 容器：有效元素的存储空间，不包括多余容量； 容量：是为了减少哪些使用连续空间（线性空间）存储元素的容器在增加元素时重新分配内存的次数的一种限制，即当增加元素且剩余空间不足时，按照一定比例多分配出一些空闲空间以备将来再增加元素时使用。多余出来的容量是未经初始化的（注意：并没有调用元素类型的默认构造函数来初始化）。 有效元素：调用元素类型的默认构造函数初始化过的存储空间。 std:
传说的向量结构 STL+std::vector；
weixin_74236594的博客
12-28 760
vector 带名；//指定初始化的大小：解释 vector 与std::vector 的区别；两者是相同的，vector 是std 命名域的；及std::vector;有三个字符串组成的长量；大小为零的向量；填充数据的向量；i
C++11: 尽量使用std::array来代替数组
danxibaoxxx的博客
11-15 2632
std::array是具有固定大小的数组，使用栈（静态内存分配）。支持快速随机访问，效率与数组相同。不能添加或删除元素。 需要包含头的头文件文件#include<array> 定义时必须指定array的大小，因为大小是模板参数之一，不可忽略； 定义时不能使用变量指定大小； 可通过array构造新的array，可以使用{}构造； 不可使用数组构造。 array<int,5>myarray={1,2,3,4,5}; array<int,5>othera...
C++:STL:vector: move赋值构造；右值引用；
mzhan017的博客
11-28 1991
理解这个的首要任务是理解 &&；两个地址符的含义就是对右值的引用；
C++ std::vector
休息一下接着来的博客
07-31 802
标准库类型vector表示对象集合，其中所有的对象的类型都相同。vector常常被称为容器（container）。使用vector时，需要引入对应的头文件。vector本质上是一个类模板。 #include <vector> // 包含对应的头文件 using std::vector 1. vector的定义和初始化 vector<T> v1; // v1 是一个空vector，它潜在的元素是T类型，执行默认初始化 vector<T> V2(V1); //
C++标准模板库(STL)——vector常见用法详解
最新发布
qq_46735055的博客
05-11 693
insert(it, x)用来向vector的任意迭代器it处插入一个元素x，时间复杂度为O(n)。push_back(x)功能为在vector后面添加一个元素x，时间复杂度为O(1)。erase()既可以删除单个元素，还可以删除一个区间的所有元素。时间复杂度为O(n)。pop_back()用来删除vector的尾元素，时间复杂度为O(1)。size()用来获得vector中元素的个数，时间复杂度为O(1)。clear()用来清空vector中的所有元素，时间复杂度为O(n)。删除一个区间内的所有元素。
C++语法——创建vector<T>容器
JosiasAnas的博客
05-07 1347
vector<T> 容器是包含 T 类型元素的序列容器，和 array<T，N> 容器相似，不同的是 vector<T> 容器的大小可以自动增长，从而可以包含任意数量的元素；因此类型参数 T 不再需要模板参数 N。只要元素个数超出 vector 当前容量，就会自动分配更多的空间。只能在容器尾部高效地删除或添加元素。 vector<T> 容器可以方便、...
[C++] 基础教程 - std::vector库介绍和使用场景
老狼工作室的博客
12-07 1282
std::vector是C++标准库中的一个动态数组容器，它可以自动调整大小以容纳任意数量的元素。std::vector提供了一种高效的方式来存储和操作数据，同时还具有很好的灵活性和可扩展性。
不允许使用“{...}”对”std::vector<int,std::allocator<int> >“类型的对象进行初始化
NancyDeng的博客
11-28 1万+
数组赋值时常用的方法就是：int a[]={1,2,3};但是，对于vector却不能这么干，这种想当然的错误经常会犯。vector<int> v={1,2,3};因此，vector不能像数组一样赋值，而只能通过提供的接口进行操作。说白了就是，不知道的东西不乱用。
STL源码剖析之allocator&vector
qq_41105501的博客
10-25 781
STL源码剖析之Allocator&vector 结合以前学习《STL源码剖析》笔记、理解（与当前版本部分实现细节存在差异），针对gcc6.4.1 STL源码(基于cpp11特性)的设计思想、实现细节作了分析。列出了一系列重要函数，对部分重点设计方式、实现细节做了注释。由于个人技术及文档编排水平有限，可能存在各种问题，欢迎指出及交流讨论。后续会基于本人的优化经验，发布出基于STL底层实现的优化。当然也会分享一些使用SGI STL的注意事项。本系列会保持更新。 文章目录1.对象构造/析构 const
std::vector
TimerSea的博客
03-29 2185
std::vector 应用记录
std::vector使用总结
热门推荐
大山喵写博客的地方
10-12 2万+
Vector 　　Vector描述的是一个动态数组（dynamic array），并提供了相关操作和接口。 　　在使用Vector之前，需要引入头文件#include&amp;amp;amp;amp;lt;vector&amp;amp;amp;amp;gt;，在此头文件中，类型vector是一个定义于namespace std内的template： template&amp;amp;amp;amp;lt; class T, class Allocator
深度解析C++ STL容器vector原理及用法
紫荆鱼的博客
01-01 2362
vector是表示可以改变大小的数组的序列容器. 就像数组一样，向量为它们的元素使用连续的存储位置，这意味着它们的元素也可以使用指向其元素的常规指针上的偏移量来访问，并且与在数组中一样有效. 但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。
C++ STL详解：向量vector与标准模板库
"向量容器vector是C++标准模板库STL中的一个重要组成部分，它是一个动态数组，能够容纳不定长度的线性序列，并且支持随机访问。STL是C++的一个通用库，由模板类和函数模板组成，强调泛型编程，提供容器、迭代器、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值