C++ 标准模板库(STL)
STL(Standard Template Libary) 标准模板库 是通用类和算法的集合, 提供给程序员一些标准的操作数据结构的实现 Queues(队列) Stack (栈) Lists( 链表) 和 Sets(二叉树)
1.Vectors 向量容器
Vectors包含着一系列连续存储的元素,其行为和数组类似
构造函数:
vector();
//在vectors 放入 num个 val值 的 数据
vector( size_type num, const TYPE &val );
//拷贝构造函数
vector( const vector &from );
//利用迭代器进行区间赋值
vector( input_iterator start, input_iterator end );
关于运算符:
定义vector:
#include <vector>
vector <类型> v;
vector <类型> v(5,'m');
注意:要引入头文件
常用接口:
1.push_back() 函数
函数原型:
void push_back( const TYPE &val );
作用:
在vector末尾插入数据val
2.size() 函数
函数原型:
void resize( size_type size, TYPE val );
作用:
返回当前vector所容纳元素的数目
3.pop_back() 函数
原型:
void pop_back();
作用:
在vector末尾删除数据
4.erase() 函数
函数原型:
iterator erase( iterator loc ); //删作指定位置loc的元素
iterator erase( iterator start, iterator end );//删除区间[start, end)的所有元素.
返回值:
返回值是指向删除的最后一个元素的下一位置的迭代器
-
insert() 函数
函数原型:
//在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器
iterator insert( iterator loc, const TYPE &val );
//在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器
void insert( iterator loc, size_type num, const TYPE &val );
在指定位置loc前插入区间[start, end)的所有元素 .
void insert( iterator loc, input_iterator start, input_iterator end );
2.STL库中的迭代器
迭代器可被用来访问一个容器类的所包函的全部元素，其行为像一个指针。 -- 按照指针去操作
Iterators(迭代器) -- 就是指针
begin() 函数
函数原型:
iterator begin();
作用:
返回指向当前vector第一个元素的迭代器
end() 函数
函数原型:
iterator end();
作用:
返回指向当前vector末尾元素下一个的迭代器 注意:访问末尾元素,需要先将此迭代器自减1
关于迭代器的原理:
案例:
| C++
#include <iostream>
//引入模板类的头文件
#include <vector>
using namespace std;
int main(int argc, char const *argv[])
{
//定义vector 模板类 -- 实例化时必须指定类型
vector <int> v;
v.push_back(100);
v.push_back(200);
v.push_back(300);
v.push_back(400);
vector<int>::iterator it = v.begin();
for(;it != v.end();it++){
//查找要删除的位置
if( *it == 300){
v.erase(it);
break;
}
}
//经过erase的操作,此时it迭代器指向的是删除元素的后一个迭代器
// 所以 如果想要重新遍历所有元素 需要将it迭代器指回 begin()
for(it = v.begin();it != v.end(); it++){
cout << *it << endl;
}
//使用迭代器遍历输出(指针)
//定义迭代器
// vector<int>::iterator it;
// // it = v.begin();
// // it = v.end()-1;
// // cout << *it << endl;
// for(it = v.begin(); it != v.end(); it++){
// cout << *it << endl;
// }
return 0;
}
//练习 vector中存储 Person类 (姓名name 年龄age)
// 使用迭代器遍历 |
3.C++ Double Ended Queues(双向队列)
双向队列和向量很相似，但是它允许在容器头部快速插入和删除（就像在尾部一样）。
相比于vector接口,只多了两个头部操作接口
pop_front() 函数
删除双向队列头部的元素。
push_front() 函数
向双向队列头部添加元素。
4.C++ Lists(链表)
Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.
| C++
list<int> first; // 定义空链表
list<int> second (4,100); // 向链表中插入4个数据,每个数据值是100
list<int> third (second.begin(),second.end()); // 把一个区间赋值给当前链表
list<int> fourth (third); // 拷贝构造函数 |
常用接口
merge () 合并两个链表
函数原型:
void merge( list &lst );
void merge( list &lst, Comp compfunction );
作用:
merge()函数把自己和lst链表连接在一起，产生一个整齐排列的组合链表。如果指定compfunction，则将指定函数作为比较的依据。
| C++
#include <iostream>
#include <list>
using namespace std;
int main(int argc, char const *argv[])
{
//list实例化
list<int> first, second;
first.push_back(10);
first.push_back(20);
first.push_back(30);
first.push_back(40);
second.push_front(100);
second.push_front(200);
second.push_front(300);
second.push_front(400);
//使用迭代器显示链表
// for(auto it = first.begin();it != first.end();it++){
// cout << *it << " " << endl;
// }
// cout << "---------------" << endl;
// for(auto it = second.begin();it != second.end();it++){
// cout << *it << " " << endl;
// }
first.merge(second);
for(auto it = first.begin();it != first.end();it++){
cout << *it << " " << endl;
}
cout << "---------------" << endl;
return 0;
} |
排序接口
sort() 排序接口
函数原型:
void sort();
void sort( Comp compfunction );
作用:
sort()函数为链表排序，默认是升序。如果指定compfunction的话，就采用指定函数来判定两个元素的大小。
unique() 去除重复的数据
语法:
void unique();
void unique( BinPred pr );
5.C++ Sets(二叉树)
集合(Set)是一种包含已排序对象的关联容器 ---- 二叉树
构造函数:
| C++
set<int> first; // 空的set容器--二叉树
int myints[]= {10,20,30,40,50};
set<int> second (myints,myints+5); // 向set中放入5个数据
set<int> third (second); // 拷贝构造函数
set<int> fourth (second.begin(), second.end()); // 使用迭代器进行区间赋值
set<int,classcomp> fifth; // 指定比较方法 classcomp结构体类型 |
insert() 插入数据
| C++
iterator insert( iterator i, const TYPE &val );
void insert( input_iterator start, input_iterator end );
pair insert( const TYPE &val ); |
说明：
● 在迭代器i前插入val；
● 将迭代器start开始到end结束返回内的元素插入到集合中；
● 在当前集合中插入val元素，并返回指向该元素的迭代器和一个布尔值来说明val是否成功的被插入了。
（应该注意的是在集合(Sets)中不能插入两个相同的元素。)
| C++
#include <iostream>
#include <set>
using namespace std;
int main(int argc, char const *argv[])
{
set<int> tree;
tree.insert(123);
tree.insert(3);
tree.insert(12);
tree.insert(13);
tree.insert(34);
tree.insert(56);
//遍历二叉树
for(auto it=tree.begin(); it != tree.end();it++){
cout << *it << " " << endl;
}
return 0;
}
//使用set容器存储 Person (string name, int age) 按照age排序
// 具体方式可以参考英文手册 |
重新定义比较函数----降序
| C
//重新定义比较方法--const修饰函数 就是为了保证函数内不修改对象的任何数据成员
//比较函数通常都会叫const
struct classcomp
{
bool operator()(const person&l,const person &r) const
{
return l.age > r.age;
}
}; |
比较自定义数据类型
| C
#include <iostream>
#include <set> //二叉树
using namespace std;
//按照年龄降序输出
class person
{
public:
person(){}
person(string name, int age):name(name),age(age){}
string name;
int age;
friend bool operator<(person &a, person &b);
};
bool operator<(const person &a,const person &b){
return a.age < b.age;
}
//重新定义比较方法--const修饰函数 就是为了保证函数内不修改对象的任何数据成员
//比较函数通常都会叫const
struct classcomp
{
bool operator()(const person&l,const person &r) const
{
return l.age > r.age;
}
};
int main(int argc, char const *argv[])
{
// set<person> s;
set<person,classcomp> s;
person p1("张三", 20);
person p2("李四", 26);
person p3("王五", 17);
person p4("赵六", 29);
s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);
for (auto it = s.begin(); it != s.end(); it++)
{
cout << "姓名:" << it->name << endl;
cout << "年龄:" << it->age << endl;
cout << "+++++++++++++++++++++" << endl;
}
return 0;
} |
6.map 容器
| C++
Maps 被用作储存“关键字/值”对
key / value 每一个key对应一个value
map容器中所有数据都是成对存在的 -- pair 对组
#include <iostream>
using namespace std;
int main(int argc, char const *argv[])
{
//map中所有数据都是成对出现的
pair<int,string> a(10010,"小王");
// 取出数据中的键和值
cout << a.first << endl; //key
cout << a.second << endl; //value
return 0;
} |
1.map的构造函数:
| C++
1.map<char,int> first; // 定义一个空的map容器
//往 map中插入数据
first['a']=10;
first['b']=30;
first['c']=50;
first['d']=70;
2.map<char,int> second (first.begin(),first.end()); //区间赋值
3.map<char,int> third (second); // 拷贝构造函数
4.map<char,int,classcomp> fourth; //设置map的排序方式 |
2.map接口
insert() 插入接口
| C++
iterator insert( iterator pos, const pair<KEY_TYPE,VALUE_TYPE> &val );//插入val到pos的后面，然后返回一个指向这个元素的迭代器。
void insert( input_iterator start, input_iterator end );
//插入start到end的元素到map中。
pair<iterator, bool> insert( const pair<KEY_TYPE,VALUE_TYPE> &val );
//只有在val不存在时插入val。返回值是一个指向被插入元素的迭代器和一个描述是否插入的bool值
如果插入数据 , 也可以使用重载的 [ ] , 按照键(下标)的形式进行插入
#include <iostream>
#include <map>
using namespace std;
int main(int argc, char const *argv[])
{
//定义一个空的map
map<int,string> m;
//插入数据 -- 第一种 map的插入接口
// m.insert(pair<int,string>(1,"苏泉"));
// m.insert(pair<int,string>(2,"张强"));
// m.insert(pair<int,string>(3,"老赖"));
// m.insert(pair<int,string>(4,"蜗牛"));
//重载后的 [] 插入数据 -- 第二种
m[1] = "苏泉";
m[2] = "张强";
m[3] = "孙楠";
m[4] = "蜗牛";
//遍历map
for(auto it=m.begin(); it != m.end();it++){
cout << "key:" << it->first << endl;
cout << "value:" << it->second << endl;
}
//利用重载[]的方法访问数据
cout << m[4] << endl;
return 0;
} |
find ()查找接口
| C++
iterator find( const KEY_TYPE &key );
find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器
#include <iostream>
#include <map>
using namespace std;
class base
{
public :
base(){}
base(string name): name(name){}
string name;
};
int main(int argc, char const *argv[])
{
//定义一个空的map
map<int,base> m;
base a("张三");
base b("李四");
base c("王五");
//插入数据 -- 第一种 map的插入接口
// m.insert(pair<int,base>(1,a));
// m.insert(pair<int,base>(2,b));
// m.insert(pair<int,base>(3,c));
//重载后的 [] 插入数据 -- 第二种
m[1] = a;
m[2] = b;
m[3] = c;
//遍历map
for(auto it=m.begin(); it != m.end();it++){
cout << "key:" << it->first << endl;
cout << "value:" << it->second.name << endl;
}
//利用重载[]的方法访问数据
cout << m[4].name << endl;
auto value = m.find(3);
cout << value->second.name << endl;
return 0;
}
// 练习: 使用map存储键值对中值为base的类型 |
目录
扫一扫
445
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
