新闻  |   论坛  |   博客  |   在线研讨会
两万字总结《C++ Primer》要点(4)
机器之心 | 2021-04-08 20:26:36    阅读:356   发布文章

第十一章 关联容器

P374-P397

关联容器支持高效的关键字查找和访问。


11.1 使用关联容器
map是关键词-值对的集合。
为了定义一个map,我们必须指定关键字和值的类型。
// 统计每个单词在输入中出现的次数
map<string, size_t> word_count;
string word;
while (cin >> word)
    ++word_count[word];
for (const auto &w : word_count)
  count << w.first << " cccurs " < w.second 
  << ((w.second > 1) ? " times" : "time") << endl;

set是关键字的简单集合。

为了定义一个set,必须指定其元素类型。


// 统计输入中每个单词出现的次数,并忽略常见单词
map<string, size_t> word_count;
set<string> exclude = {"the", "But"};
string word;
while (cin >> word)
// 只统计不在exclude中的单词
if (exclude.find(word) == exclude.end())
++word_count[word]; //获取并递增word的计数器

11.2 关联容器概述

(1)定义关联容器

定义map时,必须指明关键字类型又指明值类型;

定义set时,只需指明关键字类型。

(2)pair类型

pair标准库类型定义在头文件utility中。

一个pair保存两个数据成员。当创建一个pair时,必须提供两个类型名。


pair<string, string> anon; // 保存两个string
pair<string, string> author{"James", "Joyce"}; // 也可为每个成员提供初始化器

pair的数据类型是public的,两个成员分别命名为first和second。

pair上的操作,见表,P380

11.3 关联容器操作

关联容器额外的类型别名

key_type:此容器类型的关键字类型

mapped_type:每个关键字关联的类型,只适用于map

value_type:对于set,与key_type相同;对于map,为pair<const key_type, mapped_type>

(1)关联容器迭代器

set的迭代器是const的

set和map的关键字都是const的

遍历关联容器:

map和set都支持begin和end操作。使用beigin、end获取迭代器,然后用迭代器来遍历容器。

(2)添加元素

2.png

(3)删除元素

从关联容器删除元素

c.erase(k):从c中删除每个关键字为k的元素。返回一个size_type值,指出删除的元素的数量

c.erase(p):从c中删除迭代器p指定的元素。p必须指向c中一个真实元素,不能等于c.end()。返回一个指向p之后元素的迭代器,若p指向c中的尾元素,则返回.end()

c.erase(b, e):删除迭代器b和e所表示的范围中的元素。返回e

(4)map的下标操作

map和unorder_map的下标操作

c[k]:返回关键字为k的元素;如果k不在c中,添加一个关键字为k的元素,对其进行值初始化

c.at[k]:访问关键字为k的元素,带参数检查;若k不在c中,抛出一个out_of_range异常

::: tip

map进行下标操作,会获得mapped_type对象;当解引用时,会得到value_type对象。

:::

(5)访问元素


c.find(k)  // 返回一个迭代器,指向第一个关键字k的元素,如k不在容器中,则返回尾后迭代器
c.count(k)  // 返回关键字等于k的元素的数量。对于不允许重复关键字的容器,返回值永远是0或1
c.lower_bound(k)  // 返回一个迭代器,指向第一个关键字不小于k的元素;不适用于无序容器
c.upper_bound(k)  // 返回一个迭代器,指向第一个关键字大于k的元素;不适用于无序容器
c.equal_bound(k)  // 返回一个迭代器pair,表示关键字等于k的元素的范围。如k不存在,pair的两个成员均等于c.end()

11.4 无序容器

无序容器使用关键字类型的==运算符和一个hash<key_type>类型的对象来组织元素。

无序容器在存储上组织为一组桶,适用一个哈希函数将元素映射到桶。

无序容器管理操作,表格,P395

还可以自定义自己的hash模板 P396


using SD_multiset = unordered_multiset<Sales_data, decltype(hasher)*, decltype(eqOp)*>;
SD_multiset bookStore(42, haser, eqOp);

第十二章 动态内存

P400-P436

12.1 动态指针与智能指针

智能指针用途

shared_ptr:提供所有权共享的智能指针:对共享对象来说,当最后一个指向它的shared_ptr被销毁时会被释放。

unique_ptr:提供独享所有权的智能指针:当unique_ptr被销毁的时,它指向的独享被释放。unique_ptr不能直接拷贝或赋值。

weak_ptr:一种智能指针,指向由shared_ptr管理的对象。在确定是否应释放对象视,shared_ptr并不把weak_ptr统计在内。

(1)shared_ptr类

shared_ptr<string> p1;

make_shared函数:

make_shared在动态内存中分配一个对象并初始化它,返回此对象的shared_ptr。

share_ptr<int> p3 = make_shared<int>(42);

shared_ptr的拷贝和赋值:

每个shared_ptr都有一个关联的计数器,称为引用计数。一旦一个shared_ptr的引用计数变为0,就会自动释放自己所管理的对象。

(2)直接管理内存

运算符new分配分配内存,delete释放new分配的内存。

使用new动态分配和初始化对象:


// 默认情况下,动态分配的对象是默认初始化的
int *pi = new int; // pi指向一个动态分配的、未初始化的无名对象


// 直接初始化方式
int *pi = new int(1024); // pi指向的对象的值为1024


// 对动态分配的对象进行值初始化,只需在类型名之后加上一对空括号
int *pi1 = new int;   // 默认值初始化;*pi1的值未定义
int *pi2 = new int(); // 值初始化为0;*pi2为0

动态分配的const对象:

const int *pci = new const int(1024);

释放动态内存:

delete p;

delete表达式执行两个动作:销毁给定的指针指向的对象;释放对应的内存。

(3)unique_ptr

某个时刻,只能有一个unique_ptr指向一个给定对象。

当unique_ptr销毁时,它所指向的对象也被销毁。

unique_ptr操作

unique_ptr<T> u1

unique_ptr<T, D> u2

unique_ptr<T, D> u(d)

u = nullptr

u.release()

u.reset()

u.reset(p)

u.reset(nullptr)

(4)weak_ptr

weak+ptr是一种不受控制所指向对象生存期的智能指针,它指向由一个shared_ptr管理的对象,而且不会改变shared_ptr的引用计数。

weak_ptr 操作

weak_ptr<T> w

weak_ptr<T> w(sp)

w = p

w.reset()            将w置空

w.use_count()            与w共享对象的shared_ptr的数量

w.expired()

w.lock()

使用weak_ptr之前,需要调用lock,检查weak_ptr指向的对象是否存在。

12.2 动态数组

(1)new和数组

在类型名之后跟一对方括号,在其中指明要分配的对象的数目。

释放动态数组:


delete p;      // p必须指向一个动态分配的对象或为空
delete [] pa;  // pa必须指向一个动态分配的数组或为空

智能指针和动态数组


unique_ptr<T []> u;
unique_ptr<T []> u(p);
u[i];

(2)allocator类

标准库allocator类定义在头文件memory中,帮助将内存和对象构造分离开来。


allocator<string> alloc;
auto const p = alloc.allocate(n);

表达式                  作用

allocator[T] a:定义了一个名为a的allocator对象,它可以为类型为T的对象分配内存

a.allocate(n):分配一段原始的、未构造的内存,保存n个类型为T的对象

a.construct(p, args):为了使用allocate返回的内存,我们必须使用construct构造对象。使用未构造的内存,其行为是未定义的。

a.destroy(p):p为T*类型的指针,此算法对p指向的对象执行析构函数

术语

new : 从自由空间分配内存。new T 分配并构造一个类型为T的指针。如果T是一个数组类型,new 返回一个指向数组首元素的指针。类似的,new  [n]  T 分配 n 个类型为T的对象,并返回指向数组首元素的指针。

空悬指针:一个指针,指向曾经保存一个对象但现在已释放的内存。

智能指针:标准库类型。负责在恰当的时候释放内存。

*博客内容为网友个人发布,仅代表博主个人观点,如有侵权请联系工作人员删除。

参与讨论
登录后参与讨论
推荐文章
最近访客