标准模板库自修教程与参考手册 STL进行C++编程 第2版PDF|Epub|txt|kindle电子书版本下载

标准模板库自修教程与参考手册 STL进行C++编程 第2版PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

第1部分 STL基础入门1

第1章 概述1

1.1 本书读者2

1.2 类属编程的概念及重要性2

1.3 C++模板与类属编程4

1.3.2 函数模板6

1.3.3 成员函数模板8

1.3.4 模板参数的明确说明8

1.3.5 默认模板参数9

1.3.6 部分说明10

1.4 模板的代码膨胀问题10

1.5 理解STL性能保证10

1.5.1 大O表示法与相关定义10

1.5.2 分摊的时间复杂度11

1.5.3 大O表示法的局限性12

第2章 STL组件概述13

2.1 容器13

2.1.1 序列容器13

2.1.2 有序关联容器17

2.2 类属算法18

2.2.1 类属查找算法18

2.2.2 类属合并算法21

2.3 迭代器23

2.4 函数对象26

2.5 适配器30

2.6 分配器32

第3章 STL与其他软件库的区别33

3.1 可扩展性33

3.2 组件的互换性34

3.3 算法/容器兼容性35

第4章 迭代器36

4.1 输入迭代器36

4.2 输出迭代器38

4.3 前向迭代器39

4.4 双向迭代器40

4.5 随机访问迭代器41

4.6 STL迭代器层次结构：算法与容器之间的高效结合42

4.7 插入迭代器44

4.8 再论输入与输出：流迭代器46

4.9 STL算法对迭代器类型要求的定义47

4.10 类属算法设计48

4.11 算法对迭代器的更高要求49

4.12 正确选择算法50

4.13 常量迭代器和可变迭代器51

4.14 STL容器的迭代器分类52

5.1 STL基本算法组织55

5.1.1 原地形式和复制形式55

第5章 类属算法55

5.1.2 具有函数参数的算法57

5.2 非可变序列算法58

5.2.1 find58

5.2.2 adjacent_find59

5.2.3 count60

5.2.4 for_each61

5.2.5 mismatch和equal62

5.2.6 search65

5.3.1 copy和copy_backward67

5.3 可变序列算法67

5.3.2 fill68

5.3.3 generate69

5.3.4 partition70

5.3.5 random_shuffle72

5.3.6 remove73

5.3.7 replace74

5.3.8 reverse74

5.3.10 swap75

5.3.9 rotate75

5.3.11 swap_ranges76

5.3.12 transform77

5.3.13 unique78

5.4 排序相关的算法79

5.4.1 比较关系79

5.4.2 非降序(升序)与非升序(降序)82

5.4.3 sort,stable_sort和partial_sort83

5.4.4 nth_element86

5.4.5 binary_search, lower_bound, upper_bound和equal_range87

5.4.6 merge89

5.4.7 集合操作和有序结构90

5.4.8 堆操作92

5.4.9 最小值和最大值93

5.4.10 词典序比较94

5.4.11 排列生成器95

5.5 通用数值算法96

5.5.1 accumulate96

5.5.2 partial_sum97

5.5.3 adjacent_difference98

5.5.4 inner_product98

第6章 序列容器101

6.1 向量102

6.1.1 类型102

6.1.2 构造序列103

6.1.3 插入107

6.1.4 删除112

6.1.5 访问器114

6.1.6 相等和小于关系115

6.1.7 赋值116

6.2 双端队列117

6.2.2 构造函数119

6.2.1 类型119

6.2.4 删除120

6.2.5 访问器120

6.2.6 相等和小于关系120

6.2.7 赋值120

6.3 链表120

6.2.3 插入120

6.3.2 构造函数122

6.3.3 插入122

6.3.1 类型122

6.3.4 删除123

6.3.5 拼接124

6.3.6 排序相关的成员函数126

6.3.7 清除127

6.3.8 访问器127

6.3.9 相等和小于关系127

6.3.10 赋值127

第7章 有序关联容器128

7.1.1 类型129

7.1 集合和多集129

7.1.2 构造函数130

7.1.3 插入130

7.1.4 删除133

7.1.5 访问器135

7.1.6 相等和小于关系138

7.1.7 赋值138

7.2 映射和多映射138

7.2.1 类型139

7.2.3 插入140

7.2.2 构造函数140

7.2.4 删除144

7.2.5 访问器144

7.2.6 相等和小于关系145

7.2.7 赋值145

第8章 函数对象146

8.1 通过函数指针传递函数参数146

8.2 通过模板参数定义函数对象的优越性148

8.3 STL所提供的函数对象152

9.1 栈容器适配器153

第9章 容器适配器153

9.2 队列容器适配器155

9.3 优先级队列容器适配器157

第10章 迭代器适配器160

第11章 函数适配器163

11.1 绑定器163

11.2 取反器164

11.3 函数指针适配器166

12.1 查找给定单词的变位词169

第12章 为字典检索编程169

第2部分 综合运用：示例程序169

12.2 使用标准流和I/O流类交互171

12.3 产生全排列并检索词典173

12.4 完整程序174

12.5 程序运行速度175

第13章 编程查找所有变位词组177

13.1 查找变位词组177

13.2 定义STL使用的数据结构178

13.3 创建用于比较的函数对象179

13.5 将字典读入PS对象的向量180

13.4 完成变位词组检索程序180

13.6 使用比较对象排序单词对181

13.7 使用等同判定对象搜索临近的相同元素181

13.8 使用函数适配器包含判定对象182

13.9 将变位词组对复制到输出流182

13.10 变位词程序的输出183

第14章 更好的变位词程序：使用表和映射容器184

14.1 包含迭代器对的数据结构184

14.2 在表映射中存储信息184

14.3 按大小顺序输出变位词组185

14.4 更好的变位词程序186

14.5 程序的输出187

14.6 使用映射容器的原因188

第15章 更快的变位词程序：使用多映射190

15.1 搜索变位词组，版本3190

15.2 多映射的声明192

15.3 将词典读入多映射193

15.4 在多映射中查找变位词组193

15.7 程序的速度195

15.5 按照个数多少输出变位词组195

15.6 程序的输出195

第16章 定义迭代器类196

16.1 迭代器新类型：计数迭代器196

16.2 计数迭代器类197

第17章 组合STL和面向对象编程202

17.1 使用继承和虚函数202

17.2 避免容器实例的“代码膨胀”207

18.1 按日期对学生排序209

第18章 显示理论计算机科学族谱的程序209

18.2 关联学生和导师210

18.3 查找树根211

18.4 读取文件214

18.5 打印结果216

18.6 完整的“族谱”程序217

第19章 用于记时的类属算法的类218

19.1 精确测定算法时间的障碍218

19.2 排除障碍219

19.3 进一步优化221

19.4 使用Timer类自动分析222

19.4.1 报告最后结果225

19.5 STL Sort算法计时227

第3部分 STL参考指南231

第20章 迭代器参考指南231

20.1 输入迭代器的要求232

20.2 输出迭代器的要求233

20.3 前向迭代器的要求234

20.4 双向迭代器的要求234

20.6 迭代器特性235

20.5 随机访问迭代器的要求235

20.6.1 迭代器基类236

20.6.2 标准迭代器标记237

20.7 迭代器运算238

20.8 流迭代器238

20.8.1 文件238

20.8.2 类声明238

20.8.5 类型定义239

20.8.6 构造函数239

20.8.3 示例239

20.8.4 描述239

20.8.7 公共成员函数240

20.8.8 比较运算240

20.9 输出流迭代器240

20.9.1 文件240

20.9.4 描述241

20.9.5 类型定义241

20.9.6 构造函数241

20.9.3 示例241

20.9.2 类声明241

20.9.7 公共成员函数242

20.10 反向迭代器242

20.10.1 文件242

20.10.2 类声明242

20.10.3 示例242

20.10.4 描述243

20.10.5 构造函数243

20.10.6 公共成员函数243

20.10.7 全局算法244

20.11.3 示例245

20.11.2 类声明245

20.11.4 描述245

20.11 后向插入迭代器245

20.10.8 相等性和顺序判定245

20.11.1 文件245

20.11.5 构造函数246

20.11.6 公共成员函数246

20.11.7 相应的模板函数246

20.12 前向插入迭代器246

20.12.1 文件246

20.12.2 类声明246

20.12.3 构造函数246

20.12.4 公共成员函数247

20.12.5 相应的模板函数247

20.13 插入迭代器247

20.13.1 文件247

20.13.2 类声明247

20.13.3 示例247

20.13.6 相应的模板函数248

20.13.4 构造函数248

20.13.5 公共成员函数248

第12章 容器参考指南249

21.1 预备知识249

21.1.1 STL容器的基本设计和组织249

21.1.2 容器的公共成员250

21.1.3 可逆容器的要求252

21.1.4 序列容器的要求253

21.1.5 关联容器的要求254

21.2 容器类描述的组织257

21.2.1 头文件257

21.2.2 类的声明257

21.2.3 示例257

21.2.4 描述257

21.2.11 附注部分258

21.3 向量258

21.2.10 删除数据的成员函数258

21.3.2 类的声明258

21.3.1 头文件258

21.2.9 插入数据的成员函数258

21.2.8 访问数据的成员函数258

21.2.7 比较操作258

21.2.6 构造函数、析构函数及相关函数258

21.2.5 类型定义258

21.3.3 示例259

21.3.4 描述259

21.3.5 类型定义259

21.3.6 构造函数、析构函数及相关函数260

21.3.7 比较操作261

21.3.8 向量元素访问成员函数262

21.3.9 向量插入成员函数263

21.3.10 向量删除成员函数263

21.3.11 关于向量插入成员函数和删除成员函数的附注264

21.4 双端队列264

21.4.1 头文件264

21.4.2 类的声明264

21.4.5 类型定义265

21.4.6 双端队列构造函数、析构函数及相关函数265

21.4.3 示例265

21.4.4 描述265

21.4.7 比较操作266

21.4.8 双端队列元素访问成员函数266

21.4.9 双端队列插入成员函数268

21.4.10 双端队列删除成员函数268

21.5.1 头文件269

21.5.4 描述269

21.5.2 类的声明269

21.5.3 示例269

21.5 表269

21.4.12 关于双端队列删除成员函数的附注269

21.4.11 双端队列插入操作的复杂度269

21.5.5 类型定义270

21.5.6 表的构造函数、析构函数及相关函数270

21.5.7 比较操作271

21.5.8 表元素访问成员函数272

21.5.9 list类插入数据的成员函数273

21.5.10 表的删除成员函数273

21.5.11 特殊表操作：Splice, Remove, Remove If, Unique, Merge, Reverse和Sort274

21.6.5 类型定义276

21.6.4 描述276

21.6.2 类的声明276

21.6.3 示例276

21.6.1 头文件276

21.6 集合276

21.5.13 关于表删除成员函数的附注276

21.5.12 关于表插入成员函数的附注276

21.6.6 集合构造函数、析构函数及相关函数278

21.6.7 比较操作278

21.6.8 集合元素访问成员函数278

21.6.9 set类的插入数据的成员函数279

21.6.11 特殊集合操作280

21.6.10 集合删除成员函数280

21.7 多集281

21.7.1 头文件281

21.7.2 类的声明281

21.7.3 示例281

21.7.4 描述281

21.7.5 类型定义282

21.7.6 多集的构造函数、析构函数及相关函数282

21.7.7 比较操作282

21.7.9 多集插入数据成员函数283

21.7.8 多集访问数据成员函数283

21.7.11 特殊多集操作284

21.7.10 多集的删除数据成员函数284

21.8 映射285

21.8.1 头文件285

21.8.2 类的声明285

21.8.3 示例285

21.8.4 描述285

21.8.5 类型定义286

21.8.7 map类的比较操作287

21.8.6 映射的构造函数、析构函数及相关函数287

21.8.8 map类访问数据的成员函数288

21.8.9 映射插入成员函数289

21.8.10 映射删除成员函数290

21.8.11 特殊映射操作290

21.9.6 多映射的构造函数、析构函数及相关函数291

21.9.5 类型定义291

21.9.3 示例291

21.9.4 描述291

21.9.1 头文件291

21.9 多映射291

21.9.2 类的声明291

21.9.7 multimap类的比较操作292

21.9.8 多映射元素访问成员函数292

21.9.9 多映射插入成员函数293

21.9.10 多映射删除成员函数294

21.9.11 特殊多映射操作294

21.10.3 示例295

21.10.4 描述295

21.10 栈容器适配器295

21.10.2 类的声明295

21.10.1 头文件295

21.10.5 类型定义296

21.10.6 栈的构造函数296

21.10.7 栈的公共成员函数296

21.11.4 描述297

21.11.3 示例297

21.11.2 类的声明297

21.11.1 头文件297

21.11 队列容器适配器297

21.10.8 比较操作297

21.11.5 类型定义298

21.11.6 队列的构造函数298

21.11.7 公共成员函数298

21.12.4 描述299

21.12.3 示例299

21.12.2 类的声明299

21.12.1 头文件299

21.12 优先级队列容器适配器299

21.11.8 比较函数299

21.12.5 类型定义300

21.12.6 优先级队列的构造函数300

21.12.7 公共成员函数300

21.12.8 优先级队列的比较函数301

第22章 类属算法参考指南302

22.1 算法描述的组织302

22.1.1 原型302

22.2 非可变序列算法概述303

22.1.4 时间复杂度303

22.1.2 示例303

22.1.3 详细描述303

22.3 for_each304

22.3.1 原型304

22.3.2 示例304

22.3.3 详细描述304

22.3.4 时间复杂度304

22.4 find304

22.4.1 原型304

22.4.2 示例305

22.4.3 详细描述305

22.4.4 时间复杂度305

22.5 find_first_of305

22.5.1 原型305

22.5.2 详细描述305

22.5.3 时间复杂度305

22.7.1 原型306

22.7.2 示例306

22.7 count306

22.7.3 详细描述306

22.6 adjacent_find306

22.6.4 时间复杂度306

22.6.3 详细描述306

22.6.2 示例306

22.6.1 原型306

22.7.4 时间复杂度307

22.8 mismatch307

22.8.1 原型307

22.8.2 示例307

22.8.3 详细描述307

22.8.4 时间复杂度307

22.9.4 时间复杂度308

22.9.3 详细描述308

22.10 search308

22.10.1 原型308

22.9.1 原型308

22.9 equal308

22.9.2 示例308

22.10.2 示例309

22.10.3 详细描述309

22.10.4 时间复杂度309

22.11 search_n309

22.11.1 原型309

22.11.2 详细描述309

22.12.2 详细描述310

22.13 可变序列算法概述310

22.12.3 时间复杂度310

22.11.3 时间复杂度310

22.12.1 原型310

22.12 find_end310

22.14 copy311

22.14.1 原型311

22.14.2 示例311

22.14.3 详细描述311

22.15.4 时间复杂度312

22.16 transform312

22.15.3 详细描述312

22.16.1 原型312

22.14.4 时间复杂度312

22.15.2 示例312

22.15.1 原型312

22.15 swap312

22.16.2 示例313

22.16.3 详细描述313

22.16.4 时间复杂度313

22.17 replace313

22.17.1 原型313

22.17.2 示例314

22.17.3 详细描述314

22.17.4 时间复杂度314

22.18 fill314

22.18.1 原型314

22.18.2 示例314

22.18.3 详细描述314

22.19.4 时间复杂度315

22.19.3 详细描述315

22.20 remove315

22.20.1 原型315

22.19.1 原型315

22.19 generate315

22.18.4 时间复杂度315

22.19.2 示例315

22.20.4 时间复杂度316

22.21 unique316

22.21.1 原型316

22.20.3 详细描述316

22.20.2 示例316

22.21.2 示例317

22.21.3 详细描述317

22.21.4 时间复杂度317

22.22 reverse317

22.22.1 原型317

22.22.2 示例317

22.22.3 详细描述317

22.24 random_shuffle318

22.23.4 时间复杂度318

22.24.1 原型318

22.24.2 示例318

22.23.1 原型318

22.23.3 详细描述318

22.23.2 示例318

22.23 rotate318

22.22.4 时间复杂度318

22.24.3 详细描述319

22.24.4 时间复杂度319

22.25 partition319

22.25.1 原型319

22.25.2 示例319

22.25.3 详细描述319

22.25.4 时间复杂度319

22.26 有序队列算法概述320

22.27 sort321

22.27.1 原型321

22.27.2 示例321

22.28 nth_element322

22.28.1 原型322

22.27.3 详细描述322

22.27.4 时间复杂度322

22.28.2 示例323

22.28.3 详细描述323

22.28.4 时间复杂度323

22.29 binary_search323

22.29.1 原型323

22.29.4 时间复杂度324

22.30.1 原型324

22.30 merge324

22.29.3 详细描述324

22.29.2 示例324

22.30.2 示例325

22.30.3 详细描述325

22.30.4 时间复杂度325

22.31 有序结构的集合运算325

22.31.1 原型326

22.31.2 示例327

22.31.3 详细描述327

22.31.4 时间复杂度327

22.32.1 原型328

22.32 堆操作328

22.32.3 详细描述329

22.32.4 时间复杂度329

22.33 min和max329

22.33.1 原型329

22.32.2 示例329

22.34 lexicographical_compare330

22.34.3 详细描述330

22.34.2 示例330

22.34.1 原型330

22.33.4 时间复杂度330

22.33.3 详细描述330

22.33.2 示例330

22.34.4 时间复杂度331

22.35 排列生成器331

22.35.1 原型331

22.35.2 示例331

22.35.3 详细描述331

22.37.3 详细描述332

22.37.1 原型332

22.37.2 示例332

22.36 通用数字算法概述332

22.35.4 时间复杂度332

22.37 accumulate332

22.37.4 时间复杂度333

22.38 inner_product333

22.38.1 原型333

22.38.2 示例333

22.38.3 详细描述333

22.38.4 时间复杂度333

22.39.4 时间复杂度334

22.40.1 原型334

22.40 adjacent_difference334

22.39.1 原型334

22.39.3 详细描述334

22.39.2 示例334

22.39 partial_sum334

22.40.2 示例335

22.40.3 详细描述335

22.40.4 时间复杂度335

23.1.2 函数适配器336

23.1.1 函数对象336

23.1 要求336

第23章 函数对象和函数适配器参考指南336

23.2 基类337

23.3 算术运算337

23.4 比较运算338

23.5 逻辑运算338

23.6 否定适配器339

23.7 绑定适配器339

23.8 函数指针适配器340

23.9 成员函数指针适配器340

24.1.1 将分配器传递给STL容器343

24.2 分配器要求343

第24章 分配器参考指南343

24.1 概述343

24.3 默认分配器346

24.3.1 文件346

24.3.2 类的声明346

24.3.3 详细描述346

24.3.4 类型定义346

24.3.5 构造函数、析构函数和相关函数346

24.3.6 其他成员函数347

24.3.8 关于void的附注348

24.4 定制分配器348

24.3.7 比较运算348

第25章 实用程序参考指南354

25.1 概述354

25.2 比较函数354

25.3 pair354

25.3.1 文件354

25.3.5 类型定义355

25.3.7 构造函数355

25.3.6 成员变量355

25.3.2 类声明355

25.3.4 描述355

25.3.3 例子355

25.3.8 比较函数356

附录A STL头文件357

B.1.2 类声明358

B.1.1 文件358

B.1.3 描述358

附录B 字符串参考指南358

B.1 字符串类358

B.1.4 类型定义359

B.1.5 构造函数、析构函数及相关函数360

B.1.6 比较操作362

B.1.7 元素访问成员函数363

B.1.8 插入成员函数365

B.1.9 删除成员函数365

B.2.1 文件366

B.2.3 类型定义366

B.2.2 描述366

B.2 字符特性366

B.1.10 附注366

B.2.4 字符处理函数367

附录C 示例程序使用的STL包含文件369

C.1 示例17.1中使用的文件369

附录D STL资源374

D.1 STL的SGI参考实现的Internet地址374

D.2 本书示例源代码的万维网地址374

D.3 STL兼容的编译程序374

D.4 其他相关的STL和C++文档375

D.5 类属编程和STL讨论列表375

参考文献376