STL: list ,set ,pair.map的使用
/**
* K1:---------------------list的相关API------------------------------
*
* list<T> lstT;//list采用采用模板类实现,对象的默认构造形式：
list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);//构造函数将n个elem拷贝给本身。
list(const list &lst);//拷贝构造函数。
3.6.4.2 list数据元素插入和删除操作
push_back(elem);//在容器尾部加入一个元素
pop_back();//删除容器中最后一个元素
push_front(elem);//在容器开头插入一个元素
pop_front();//从容器开头移除第一个元素
insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
clear();//移除容器的所有数据
erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos);//删除pos位置的数据，返回下一个数据的位置。
remove(elem);//删除容器中所有与elem值匹配的元素。
3.6.4.3 list大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(num);//重新指定容器的长度为num，
若容器变长，则以默认值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
resize(num, elem);//重新指定容器的长度为num，
若容器变长，则以elem值填充新位置。
如果容器变短，则末尾超出容器长度的元素被删除。
3.6.4.4 list赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
list& operator=(const list &lst);//重载等号操作符
swap(lst);//将lst与本身的元素互换。
3.6.4.5 list数据的存取
front();//返回第一个元素。
back();//返回最后一个元素。
3.6.4.6 list反转排序
reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。
sort(); //list排序
*
*
*/
/**
* K2:----------------list的细节----------------------------
* 1.sort排序,需要传入二元比较函数.或者仿函数.
* 注意点:JAVA中的compare返回的是int,这里返回的是bool.
*
* 2.remove 自定义结构体,需要重写operator== 的二元函数.
*
*/
/**
* K3:-------------------set的使用--------------------------
*
* 1.自定义类型的class,需要传入仿函数的比较器.bool operator()(const T1&,consrT2&),public修饰.
* 或者重写类内部的< 重载符.
*
* 2.移除自定义的类,需要重写operator==的二元函数.
*
*
*
* set构造函数
set<T> st;//set默认构造函数：
mulitset<T> mst; //multiset默认构造函数:
set(const set &st);//拷贝构造函数
3.7.2.2 set赋值操作
set& operator=(const set &st);//重载等号操作符
swap(st);//交换两个集合容器
3.7.2.3 set大小操作
size();//返回容器中元素的数目
empty();//判断容器是否为空
3.7.2.4 set插入和删除操作
insert(elem);//在容器中插入元素。
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
erase(elem);//删除容器中值为elem的元素。
*
*
*/
/**
*
* K4:----------------迭代器补充--------------------
* vector<int>::iterator pStart = v.begin(); //vector 容器提供了 begin()方法 返回指向第一个元素的迭代器
vector<int>::iterator pEnd = v.end(); //vector 容器提供了 end()方法 返回指向最后一个元素下一个位置的迭代器
* 并不是最后一个,而是最后一个的下一个.......
*
*
*/
/**
*
* K5:------------- == < 仿函数,谓词的总结:------------
* **都要注意加const修饰**
* bool operator==(const T &t)const 是用于remove的时候调用.
* bool operator<(const T &t)const 是用于比较排序的时候调用.
* 仿函数 也是用于比较排序的时候调用. bool operator()(const T&t1,const T &t2)const ;
*
* 这个无法加const
* 或者写一个全局函数. bool compare(const T&t1,const T &t2)
*
* 1、函数对象通常不定义构造函数和析构函数，所以在构造和析构时不会发生任何问题，避免了函数调用的运行时问题。
* 2、函数对象超出普通函数的概念，函数对象可以有自己的状态
* 3、函数对象可内联编译，性能好。用函数指针几乎不可能
* 4、模版函数对象使函数对象具有通用性，这也是它的优势之一
*
*
*/
//仿函数
class SetCompare {
public:
bool operator()(const SetPerson &p1, const SetPerson &p2) const {
return p1.age > p2.age;
}
};
//重载< 用于排序
class MapPerson {
public:
int age;
bool operator<(const MapPerson &p) const {
return this->age < p.age;
}
};
//重载== 用于比较删除
class ThreePerson {
public:
int age;
ThreePerson() {
}
ThreePerson(int age) {
this->age = age;
}
bool operator==(const ThreePerson &person) const {
return person.age == this->age;
}
~ThreePerson() {
cout << "destroy------------" << endl;
}
};
//普通函数
bool comparePerson(const ThreePerson &p1, const ThreePerson &p2) {
return p2.age > p1.age;
}
//map的使用
void printMap(map <MapPerson, string> map1) {
for (auto it = map1.begin(); it != map1.end(); ++it) {
cout << "map's age: " << it->second << endl;
}
}
void useThreeState2() {
map <MapPerson, string> map1;
auto var1 = map1.insert(make_pair(MapPerson(), "July"));
auto var2 = map1.insert(make_pair(MapPerson(), "Lucy"));
map1.insert(make_pair(MapPerson(), "LiLei"));
printMap(map1);
cout<<var1.second<<endl;//插入成功. value=July res=1
cout<<var2.second<<endl;//插入失败,value不变还是July res=0
}
网友评论