C++学习笔记——模板、STL

模板

建立通用的模具，提高复用性。

模板的特点：不可以直接使用，只是一个框架。模板的通用不是万能的。

面向对象编程思想//泛型编程——利用模板技术。

两种模板机制：函数模板，类模板

---

1 函数模板

void func(int a) {} 将void（返回值类型）和int（形参类型）抽象话，用虚拟的类型来表示。

---

template<typename T>

函数声明或定义

template：声明创建模板

typename：

T：通用的数据类型，可替换

---

模板使用方式

1.自动类型推导==== mySwap(a, b);

2.显示指定类型====== mySwap<int>(a, b);

---

普通函数调用，可以发生隐式类型转换。

函数模板用，用自动类型推导，不可以发生隐式类型转换。

函数模板用，用显示指定类型，可以发生隐式类型转换。

---

普通函数和函数模板的调用规则：

1.普通模板优先。

2.利用空模板参数列表来强制调用函数模板。

3.函数模板可以重载。

4.如果函数模板可以产生更好的匹配，函数模板优先调用。

---

STL

Standard Template Library 标准模板库

STL从广义上分为：容器（container） 算法（algorithm） 迭代器（iterator）。

容器和算法之间通过迭代器进行无缝衔接。

STL几乎所有的代码都采用了模板类或者模板函数。

---

1 STL六大组件

容器：数据结构。

算法：算法。

迭代器：连接容器和算法。

仿函数：行为类似函数，可作为算法的某种策略。

适配器（配接器）：修饰容器、仿函数、迭代器接口。

空间配置器：负责空间的配置和管理。

---

2 容器 算法 迭代器

容器

序列式容器：数组、链表、栈、队列……

关联式容器：二叉树

Algorithm：质变算法（替换、删除）/非质变算法（遍历、寻找）

迭代器：算法要通过迭代器才能访问容器中的元素。

    每个容器都有专属的迭代器。

    类似于指针。

随机访问迭代器，功能强大，常用。

---

STL常用容器

1 string

string——c++风格的字符串，本质是一个类，封装了char*。

内部封装了很多成员方法。

1.1构造函数

string();                         创建一个空字符串

string(const char* s);     利用已知字符串给string初始化

string(const string &str); 拷贝函数 利用一个string对象给另一个string对象初始化

string(int n, char c);     n个字符c组成的字符串

1.2 赋值操作

=

string& operator=(const char *s);

string& operator=(const string &str);

string& operator=(char c);

str.assign();

string& assign(const char *s);

string& assign(const char *s, int n); 把字符串s的前n个字符赋值给string

string& assign(const string &str);

string& assign(int n ,char c);

1.3 字符串拼接

+

string& operator+=(const char *s);

string& operator+=(const char c);

string& operator+=(const string &str);

str.append();

string& append(const char *c);

string& append(const char *c, int n);

string& append(const string &str);

string& append(const string &str, int pos, int n);

1.4 查找和替换

int find(); 从pos位置开始，查找字符/字符串在string里第一次出现的位置，并返回

int find(const string &str, int pos = 0)const;

int find(const char *s, int pos = 0)const;

int find(const char *s, int pos = 0, int n)const;

int rfind(); 从pos位置开始，查找字符/字符串在string里最后一次出现的位置，并返回

int rfind(const string &str, int pos = npos)const;

int rfind(const char *s, int pos = npos)const;

string& replace();

string& replace(int pos, int n, const string &str);        从pos开始的n个字符替换为str

string& replace(int pos, in n, const char *s); 从pos开始的n个字符替换为s

1.5 比较

int compare();

int compare(const string &str)const;

1.6 字符存取

[] at

2 vector

～数组，单端数组。

动态扩展：找一块更大的内存空间，拷贝原数据，释放原空间。

支持随机访问。

1.1 构造、赋值

构造

vector<T> v;

vector(v.begin(), v.end());

vector(n, elem);

vector(const vector &vec);

赋值

1.2 容量、大小

empty(); 判空

capacity(); 容量

size(); 返回元素个数

resize(int num); 重新定义vector长度为num，默认值填充/删除尾部

resize(int num, elem); 用elem填充

1.3 插入、删除、数据存取

插入

push_back(elem);   尾部插入元素elem

insert(const_iterator pos, elem);   迭代器指向位置pos处插入元素elem

insert(const_iterator pos, int count, elem); 迭代器指向位置pos处插入count个元素elem

删除

pop_back();     尾部删除元素

erase(const_iterator pos);                          删除迭代器指向位置pos的元素

erase(const_iterator start, const_iterator end);   删除迭代器指向位置从start到end之间的元素

clear();     删除容器中所有元素

数据存取

at(int idx); 返回索引 idx 所指向的数据

operator[];

front(); 返回第一个数据元素

back(); 返回最后一个元素

1.4 互换、预留

swap(vec);

reserve(int len);

3 deque

双端数组

在头部的插入删除比vector快，vector访问元素更快。

中控器——维护每段缓冲区的地址——缓冲区中存放真实数据

迭代器支持随机访问。

3.1 构造、赋值、大小

构造

deque<T>;

deque<beg, end>;

deque(n, elem);

deque(const deque &deq);

赋值

deque& operator=(const deque &deq);

assign(beg, end);

assign(n, elem);

大小

empty();

size();

resize(num);

resize(num, elem);

3.2 插入、删除

两端操作

push_front(elem); push_back(elem);

pop_front(); pop_back();

指定位置操作

insert(pos, elem); (pos为迭代器)

insert(pos, int num, elem); insert(pos, beg, end);

erase(beg, end); erase(pos);

clear();

4 list

双向链表

双向迭代器

4.1 构造、赋值、大小

构造

list<T> let; list(beg, end);

list(n, elem); list(const list &lst);

赋值

assign(beg, end); assign(n, elem);

list& operator=(const list &lst); swap(lst);

大小

size(); empty();

resize(len); resize(len, elem);`

4.2 插入、删除、反转、排序

插入、删除

push_front(elem);    push_back(elem);

pop_front();    pop_back();

insert(pos, elem);            pos--迭代器

erase(pos);

remove(elem);    删除与elem匹配的元素

front(); back(); 返回第一个元素/最后一个元素

反转、排序

所有不支持随机访问迭代器的容器，不可以用标准算法。

reverse();

sort(); 默认为升序。 若要降序，需另创建一个bool型对比函数。

sort(Compare);

5 set、multiset

所有元素在插入时自动被排序。

set、multiset属于关联式容器，底层结构是二叉树。

set不允许有重复的元素。multiset允许。 包含set头文件即可。

6 map、multimap

map中所有元素都是pair

pair<key, value>, key起到索引作用，value是元素的真实数据，map中按照key值自动排序

关联式容器，底层结构是二叉树，自动排序。