【深蓝学院C++】第9章 容器 笔记

最新推荐文章于 2022-12-31 19:10:05 发布
最新推荐文章于 2022-12-31 19:10:05 发布
阅读量376 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ASUNAchan/article/details/126574410
版权

第9章 序列与关联容器

1.概述

（1）容器：一种特殊的类型，其对象可以放置其它类型的对象（元素）

需要支持的操作：对象的添加、删除、索引、遍历

有多种算法可以实现容器，每种方法各有利弊

（2）容器分类

1序列容器：其中的对象有序排列，使用整数值进行索引

2关联容器：其中的对象顺序并不重要，使用键进行索引

3适配器：调整原有容器的行为，使得其对外展现出新的类型、接口或返回新的元素

4生成器：构造元素序列

（3）迭代器：用于指定容器中的一段区间，以执行遍历、删除等操作

获取迭代器： ©begin/©end ； ©rbegin/©rend

迭代器分类：分成 5 类（ category ），不同的类别支持的操作集合不同

#include <iostream>
#include <vector>

int main()
{
    std:::vector<int> x{1, 2, 3};
    auto b = x.begin();
    auto e = x.end();    //[b, e)
    for (auto ptr = b; ptr < e; ptr++)
    {
        std::cout << *ptr << ' ';
    }
}

2.序列容器

（1）C++ 标准库中提供了多种序列容器模板

1 array ：元素个数固定的序列容器

2 vector ：元素连续存储的序列容器

3 forward_list / list ：基于链表 / 双向链表的容器

4 deque ： vector 与 list 的折中

5 basic_string ：提供了对字符串专门的支持

（2）注意点

1需要使用元素类型来实例化容器模板，从而构造可以保存具体类型的容器。

2不同的容器虽然所提供的接口大致相同，但根据容器性质的差异，其内部实现与复杂度不同。

3对于复杂度过高的操作，提供相对较难使用的接口或者不提供相应的接口

（3）array 容器模板

1 具有固定长度的容器，其内部维护了一个内建数组，与内建数组相比提供了复制操作。

#include <iostream>
#include <array>
int main()
{
    std::array<int, 3> a;
    std::array<int, 3> b = a;
}

2 提供的接口

1）构造（与数组类似）

2）成员类型： value_type 等

#include <iostream>
#include <array>
#include <type_traits>
int main()
{
    std::array<int, 3> a;
    std::cout << std::is_same_v<std::array<int, 3>::value_type, int> ;
}

3）元素访问： [] ， at ， front ， back ， data

#include <iostream>
#include <array>

int main()
{
    std::array<int, 3> a = {1， 2， 3};
    std::cout << a[0] << std::endl;  
    std::cout << a.at(0) << std::endl;    //大于有效长度程序会崩溃
    std::cout << a.front() << std::endl; 
}

4）容量相关（平凡实现）： empty ， size ， max_size

#include <iostream>
#include <array>

int main()
{
    std::array<int, 3> a = {1， 2， 3};
    std::cout << a.size() << std::endl;  
    std::cout << a.empty() << std::endl; 
}

5）填充与交换： fill ， swap

#include <iostream>
#include <array>

int main()
{
    std::array<int, 3> a;
    a.fill(100);
    std::cout << a[0] << ' '
              << a[1] << ' '
              << a[2] << ' ' << endl;
}

6）比较操作： <=>

7）迭代器

（4）vector 容器模板：元素可变

1提供的接口

1）与 array 很类似，但有其特殊性

2）容量相关接口： capacity / reserve / shrink_to_fit

#include <iostream>
#include <vector>

int main()
{
    std:::vector<int> a;
    a.reserve(1024);
    for (int i = 0; i < 1024; i++)
    {
        a,push_back(i);
    }
}

3）附加元素接口： push_back / emplace_back

#include <iostream>
#include <vector>
#include <string>
int main()
{
    std:::vector<std::string> a;
    a.push_back("hello");
    a.emplace_back("hello");    //直接在内存中构造string
}

4）元素插入接口： insert / emplace

5）元素删除接口： pop_back / erase / clear

2注意点

vector 不提供 push_front / pop_front ，可以使用 insert / erase 模拟，但效率不高

swap 效率较高

写操作可能会导致迭代器失效

（5）list 容器模板：双向链表

1与 vector 相比， list

1）插入、删除成本较低，但随机访问成本较高

2）提供了 pop_front / splice 等接口

3）写操作通常不会改变迭代器的有效性

（6）forward_list 容器模板：单向链表

1目标：一个成本较低的线性表实现

2其迭代器只支持递增操作，因此无 rbegin/rend

3不支持 size

4不支持 pop_back / push_back

5XXX_after 操作

（7）deque容器模板： vector 与 list 的折中

push_back / push_front 速度较快

在序列中间插入、删除速度较慢

（8）basic_string 容器模板：实现了字符串相关的接口

使用 char 实例化出 std::string

提供了如 find ， substr 等字符串特有的接口

提供了数值与字符串转换的接口

针对短字符串的优化

3.关联容器

（1）使用键进行索引

1 set / map / multiset / multimap

2unordered_set / unordered_map / unordered_multiset / unordered_multimap

set / map / multiset / multimap 底层使用红黑树实现

unordered_xxx 底层使用 hash 表实现

#include <iostream>
#include <map>

int main()
{
    std::map<char, int> m{{'a', 3}, {'b', 4}};
    std::cout << m['a'] << std::endl;
}

（2）set

1通常来说，元素需要支持使用 < 比较大小，或者采用自定义的比较函数来引入大小关系

#include <iostream>
#include <set>

int main()
{
    std::set<int> s{3, 100, 45, 8};
    //std::set<int, std::greater<int>> s{3, 100, 45, 8};
    for (auto ptr = s.begin();ptr != s.end(); ptr++)
    {
        std::cout << *ptr << std::endl;
    }
}

#include <iostream>
#include <set>
struct Str
{
    int x;
};
bool Mycomp(const Str& val1, const Str& val2)
{
    return val1.x < val2.x;
}
int main()
{
    std::set<Str, decltype(&Mycomp)> s({Str{3}, Str{5}}, Mycomp);
}

2插入元素： insert / emplace / emplace_hint

#include <iostream>
#include <set>
struct Str
{
    int x;
};
bool Mycomp(const Str& val1, const Str& val2)
{
    return val1.x < val2.x;
}
int main()
{
    std::set<Str, decltype(&Mycomp)> s({Str{3}, Str{5}}, Mycomp);
    s.insert(Str{100});
    s.enplace(100);
}

3删除元素： erase

4访问元素： find / contains

#include <iostream>
#include <set>

int main()
{
    std::set<int> s{3, 100, 45, 8};
    auto ptr = s.find(3);
    if (ptr != s.end())
        std::cout << *ptr << std::endl;

    std::cout << s.contains(100) << std::endl;
}

5修改元素： extract

注意： set 迭代器所指向的对象是 const 的，不能通过其修改元素

（3）map

1树中的每个结点是一个 std::pair

#include <iostream>
#include <map>

int main()
{
    std::map<char, int> m{{'a', 3}, {'b', 4}};
    for (auto ptr = m.begin();ptr != m.end(); ptr++)
    {
        auto p = *ptr;    //std::pair<const char, int>
        std::cout << p.first << ' ' << p.second << std::endl;
    }
    //基于range-based-for
    for (auto p : m)
    {
        std::cout << p.first << ' ' << p.second << std::endl;
    }
    //或者
    for (auto [k, v] : m)
    {
        std::cout << k << ' ' << v << std::endl;
    }
}

2键 (pair.first) 需要支持使用 < 比较大小，或者采用自定义的比较函数来引入大小关系

3访问元素： find / contains / [] / at

#include <iostream>
#include <map>

int main()
{
    std::map<int, bool> m;
    m.insert(std::pair<const int, bool>(3, true));
    auto ptr = m.find(3);
    std::cout << ptr->first << '' << ptr->second;
    std::cout << m[3] << std::endl;
}

4注意

map 迭代器所指向的对象是 std::pair ，其键是 const 类型

[] 操作不能用于常量对象

#include <iostream>
#include <map>
void fun(const std::map<int, int>& m)
{
    auto ptr = m.find(3);
    if (ptr != m.end())
    {
        std::cout << ptr->second;
    }
}
int main()
{
    std::map<int, bool> m;
    m.insert(std::pair<const int, bool>(3, true));
    fun(m);
}

（4）multiset / multimap

​ 1与set / map类似，但允许重复键

#include <iostream>
#include <set>

int main()
{
    //std::set<int> s{1, 2, 4, 1};
    std::multiset<int> s{1, 2, 4, 1};
    for (auto i : s)
    {
        std::cout << i << std::endl;
    }
}

​ 2元素访问

​ 1）find 返回首个查找到的元素

#include <iostream>
#include <set>

int main()
{
    std::multiset<int> s{1, 2, 4, 1};
    auto ptr = s.find(1);
    std::cout << *ptr << std::endl;
    std::cout << *(++ptr) << std::endl;
}

​ 2）count返回元素个数

#include <iostream>
#include <set>

int main()
{
    std::multiset<int> s{1, 2, 4, 1};
    std::cout << s.count(1) << std::endl;
}

​ 3）lower_bound / upper_bound / equal_range 返回查找到的区间

#include <iostream>
#include <set>

int main()
{
    std::multiset<int> s{1, 2, 4, 1};
    auto b = s.lower_bound(1);
    auto e = s.upper_bound(1);
    for (auto ptr = b; ptr != e;++ptr)
    {
        std::cout << *ptr << std::endl;
    }
    //或者
    auto p = s.equal_range(1);
    for (auto ptr = p.first; ptr != p.second; ++ptr)
    {
        std::cout << *ptr << std::endl;
    }
}

（5）unordered_set / unordered_map / unordered_multiset / unordered_multimap

​ 1与 set / map 相比查找性能更好，但插入操作一些情况下会慢

​ 2键需要支持两个操作

​ 1）转换为 hash 值

​ 2）判等

#include <iostream>
#include <unordered_set>

int main()
{
    std::unordered_set<int> s{3, 1, 5, 4, 1};
    for (auto p : s)
    {
        std::cout << p << std::endl;
    }
}

4.适配器与生成器

（1）类型适配器

​ 1basic_string_view （ C++17 ）

​ 可以基于 std::string ， C 字符串，迭代器构造

​ 提供成本较低的操作接口

​ 不可进行写操作

#include <iostream>
#include <string_view>

void fun(std::string_view str)
{
    if (!str.empty())
        std::cout << str[0] << std::endl;
}

int main()
{
    fun("12345");   //c
    fun(std::string("12345"));  //c++
}

#include <iostream>
#include <string>
#include <string_view>

void fun(std::string_view str)
{
    std::cout << str << std::endl;
}

int main()
{
    fun("12345");   //c

    std::string s("12345");
    fun(std::string_view(s.begin(), s.begin() + 3));  //c++
}

#include <iostream>
#include <string_view>

std::string_view fun(std::string_view input)
{
    return input.substr(0, 3);
}

int main()
{
    std::string s("12345");
    auto res = fun(s);
    std::cout << res << std::endl;
}

​ 2 span （ C++20 ）

​ 可基于 C 数组、 array 等构造

​ 可读写

#include <iostream>
#include <vector>
#include <span>

void fun(std::span<int> input)
{
    for (auto p : input)
    {
        std::cout << p << ' ';
    }
    std::cout << std::endl;
}

int main()
{
    std::vector<int> s{1, 2, 3};
    fun(s);
}

（2）接口适配器

​ 1 stack / queue / priority_queue

​ 对底层序列容器进行封装，对外展现栈、队列与优先级队列的接口

​ priority_queue 在使用时其内部包含的元素需要支持比较操作

（3）数值适配器 (c++20)

​ std::ranges::XXX_view, std::ranges::views::XXX, std::views::XXX

​ 1可以将一个输入区间中的值变换后输出

​ 2数值适配器可以组合，引入复杂的数值适配逻辑

#include <iostream>
#include <vector>
#include <ranges>

bool isEven(int i)
{
    return i % 2 == 0;
}
int Square(int i)
{
    return i * i;
}
int main()
{
    std::vector<int> s{1, 2, 3, 4, 5};
    //1
    for (auto p : std::ranges::filter_view(v, isEven))
    {
        std::cout << p << ' ';
    }
    std::cout << std::endl;
    
    //2
    for (auto p : std::ranges::transform_view(v, Square))
    {
        std::cout << p << ' ';
    }
    std::cout << std::endl;
    
    //3
    auto x0 = std::views::filter(isEven);
   	for (auto p : x0(v))	//或 v | x0
    {
        std::cout << p << ' ';
    }
    std::cout << std::endl;
    
    //4
    auto x = std::views::filter(isEven);
    auto y = std::views::transform(Square);
   	for (auto p : v | x | y)	
    {
        std::cout << p << ' ';
    }
    std::cout << std::endl;
    
}

（4）生成器 (c++20)

​ std::ranges::itoa_view, std::ranges::views::itoa, std::views::itoa

​ 可以在运行期生成无限长或有限长的数值序列

#include <ranges>
#include <iostream>
 
int main()
{
    for (int i : std::ranges::iota_view{1, 10})
        std::cout << i << ' ';
    std::cout << '\n';
 
    for (int i : std::views::iota(1, 10))
        std::cout << i << ' ';
    std::cout << '\n';
 
    for (int i : std::views::iota(1) | std::views::take(9))
        std::cout << i << ' ';
    std::cout << '\n';

}
花舞の街道
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++入门编程（三）_黑马
wwwyyymm的博客
08-28 77
C++入门
【深蓝学院C++】1-6章知识点总结笔记
ASUNAchan的博客
08-21 665
深蓝学院C++学习笔记
【C++】深蓝学院课程：C++基础与深度解析 - 课程知识点目录
墨门
12-31 2007
Keywords: lambda lambda表达式 【C++】深蓝学院C++课程：C++基础与深度解析 - 课程知识点目录；
【深蓝学院C++】第14章 其它的工具与技术 笔记
ASUNAchan的博客
09-07 380
C++的一些零碎知识感觉暂时不会用到
【深蓝C++】【第2章】【知识点汇总】
qq_45954434的博客
05-04 785
【深蓝C++】【第2章】【知识点汇总】0 前言1 知识点汇总
c++课件第九章继承共29页.pdf.zip
10-29
c++课件第九章继承共29页.pdf.zip
C++程序设计教程第四版第九章购书项目源码
06-19
C++程序设计教程第四版第九章购书项目源代码，此代码是本人在学习的过程中自主仿照编写，为方便学习特此上传，若有侵权之处请及时联系删除.
C++中的vector容器对象学习笔记
12-26
C++中数组很坑，有没有类似Python中list的数据类型呢？类似的就是vector！ vector 是同一种类型的对象的集合 ，每个对象都有一个对应的整数索引值。和 string 对象一样，标准库将负责管理与存储元素相关的内存。 ...
c++容器笔记
11-27
自己总结的c++容器相关的知识笔记 有例子 虽然没有发博文 应为实在太长 但是很实用 全部以实例来讲解的
C++Primer笔记之关联容器的使用详解
12-31
关联容器  关联容器支持通过键来高效地查找和读取元素。两个基本的关联容器类型是map和set。map的元素以键-值对的形式组织：键用作元素在map的索引，而值则表示所存储和读取的数据。set仅包含一个键，并有效地支持...
深蓝内部文件
02-05
深蓝内部文件，只有内部人员可以用，违反法律必究。必究。
深蓝C++文档.pdf
12-30
深蓝C++文档 共享给大家 里面讲的挺好的
[深蓝学院]c++基础与深度解析
weixin_43096365的博客
06-08 374
c++基础与深度解析 第1章
深蓝学院C++笔记——第三章对象与基本类型之类型别名与类型的自动推导
qq_40247550的博客
05-16 114
深蓝学院C++笔记——第三章对象与基本类型之类型别名与类型的自动推导
【深蓝C++】【第3章】【知识点汇总】
qq_45954434的博客
05-08 448
【深蓝C++】【第3章】【知识点汇总】0 前言1 知识点汇总1.1 从初始化/赋值语句谈起1.2 类型详述11.2 类型详述2 0 前言 环境是ubuntu18.06 IDE是clion 1 知识点汇总 1.1 从初始化/赋值语句谈起 初始化/赋值语句是程序中最基本的操作，其功能是将某个值与一个对象关联起来 值：字面值、对象（变量或常量）所表示的值… 标识符：变量、常量、引用… 初始化基本操作 在内存中开辟空间（在栈上或在堆上），保存相应的数值 在编译器种构造符号表，将标识符与相关内存空间关联起
视觉slam爬坑——高翔深蓝学院——第五讲——非线性优化
weixin_38593194的博客
02-06 1010
这部分跟前面学旋转矩阵和李代数一样，还是很抽象的那种，有种学完了写代码还是无从下手的感觉，但是理论基础还是要过的，有什么用呢？后面学着学着就知道了。 （1）本节内容 1、最小二乘 2、非线性最小二乘 3、解决误差的两个高阶办法（高斯牛顿法和列文伯格法） （2）需要的基础知识 暂时不好描述 （3）开发环境 编译平台：ubuntu16.04， 编译软件：IDE：Clion 编译器：Cmake 语言标准...
[深蓝学院] C++ Week 4: 表达式 (expression)
weixin_42113967的博客
06-05 541
目录 1. 引入 ​​​​​​​ 1. 引入
c++primer第七章学习笔记
最新发布
08-29
很抱歉，根据提供的引用内容，我没有找到关于"C primer第七章学习笔记"的相关信息。这些引用内容主要涉及到C++编程语言的转义序列和指针的初始化，以及结构体的初始化和数组的初始化。如果你有关于C primer第七章...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值