C++进阶STL-2
目录
基本理论容器——算法——迭代器
string容器
swap技巧
deque容器基本操作
deque打分案例
set容器
对组练习
map容器
mutimap员工分组
深拷贝和浅拷贝问题
函数对象
一元二元函数对象和一元二元谓词
预定义函数对象
基本理论容器——算法——迭代器
容器中可以嵌套容器，容器可以分为序列式容器和关联式容器。
序列式容器：容器的元素的位置是由进入容器时机和地点来决定。
关联式容器：容器已经有规则，进入容器的元素的位置不是由时机和地点决定。
迭代器：可以理解为指针，对指针的操作基本都可以对迭代器操作。实际上，，迭代器是一个类，这个类封装一个指针。
算法：通过有限的步骤去解决问题。
STL容器、算法、迭代器分离案例
//算法：负责统计某个元素的个数
int mycount(int* start,int* end, int val){
int num = 0;
while(start != end){
if(*start == val){
num++;
}
start++;
}
return num;
}
int main(){
int arr[] = {0,7,5,4,9,2,0};
int* pBegin = arr;
int* pEnd = &(arr[szeof(arr)/sizeof(int)]);
int num = mycount(pBegin,pEnd,0);
cout<//STL基本语法
void test01(){
//定义一个容器，并且指定这个容器存放的元素类型是Int;
vector v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//通过STL提供的for_each算法
//容器提供的迭代器
//vector::iterator 迭代器类型
vector::iterator pBegin = v.begin();
vector::iterator pEnd = v.end();
//容器中可能存放基础的数据类型，也可能存放自定义的数据类型。
for_each(pBegin,pEnd,PrintVector);
}
//容器也可以存放自定义数据类型
class Person{
public:
Person(int age, int id):age(age),id(id){}
public:
int age;
int id;
}
void test02(){
//创建容器，并且指定容器的元素类型是Person；
vector v;
Person p1(10,20), p2(30,40), p3(50,60);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
//遍历
for(vector::iterator it = v.begin(); it!=v.end(); it++){
cout<<(*it).age<<" "<<(*it).id< string容器
char*与string的对比：string封装了char*，管理这个字符串，是一个char*型的容器。
string封装了很多实用的成员方法：find，copy，delete，replace，insert。
不用考虑内存的释放和越界。
string和char*可以互相转换：string转char*通过string提供的c_str方法。
string操作
#include
#include
using namespace std;
//char* 和string转换
void test01(){
//string类型转换为char*字符串
string s = "abc";
const char* str = s.c_str();
//char*类型转换为string类型字符串
char* str2 = "abcd";
string s2(str2);
}
//string初始化
void test02(){
string s;//默认
string s2 = "abcd";
string s3(s2);
string s4(10,'c');
cout< s2"< swap技巧
#include
#include
using namespace std;
void print(vector& v){
for(vector::iterator it = v.begin(); it != v.end(); it++){
cout<<*it<<" ";
}
}
int main(){
vector v1,v2;
for(int i = 0; i < 5; i++){
v1.push_back(i);
}
for(int i=6; i < 10; i++){
v2.push_back(i);
}
print(v1);
print(v2);
v1.swap(v2);
cout<<"v1和v2交换之后："< v;
v.resize(100);
cout << "容量：" << v.capacity() << endl;
cout << "大小:" << v.size() << endl;
v.clear();
v.push_back(2);
v.push_back(3);
cout << "容量：" << v.capacity() << endl;
cout << "大小:" << v.size() << endl;
vector(v).swap(v);
cout << "容量：" << v.capacity() << endl;
cout << "大小:" << v.size() << endl;
system("pause");
return EXIT_SUCCESS;
} deque容器基本操作
#niclude
#include
using namespace std;
//deque容器初始化
void test01(){
deque d1;//默认构造函数
deque d2(10,5);//带参数构造函数
deque d3(d2..begin(),d2.end());
deque d4(d3);//拷贝构造
}
//deque赋值操作
void test02(){
deque d1(10,3);
deque d;
d.assign(10,5);//d.assign(d1.begin(),d1.end());
d = d1;
}
//大小操作
void test03(){
deque d1(10,3);
cout<::iterator it = d.begin(); it != d.end(); it++){
cout << *it << " ";
}
cout << endl;
//删除元素
/*
while (d.size() > 0){
cout << d.back() << "被删除!" << endl;
d.pop_back();
}
cout << "大小:" << d.size() << endl;
*/
//头删除
while (!d.empty()){
cout << d.front() << "被删除!" << endl;
d.pop_front();
}
//deque容器插入
void test06(){
deque d;
d.insert(d.begin(),100); //头插法
d.insert(d.end(), 200); //尾差法
for (deque::iterator it = d.begin(); it != d.end(); it++){
cout << *it << " ";
}
cout << endl;
}
int main(){
//test03();
//test04();
test06();
system("pause");
return EXIT_SUCCESS;
} deque打分案例
#include
#include
#include
#include
#include
using namespace std;
//评委打分案例（sort算法排序）
//创建5个选手（姓名，得分），10个评委对5个选手进行打分
//得分规则：去除最高分，去除最低分，取出平均分
//按得分对5名选手进行排名
//选手类
class Player{
public:
Player(){}
Player(string name,int score):mName(name),mScore(score){}
public:
string mName;
int mScore;
}
//创建选手
void Create_Player(vector& v){
string nameSeed = "ABCDE";
for(int i = 0; i < 5; i++){
Player p;
p.mName = "选手";
p.mName+=nameSeed[i];
p.mScore = 0;
v.push_back(p);
}
}
void PrintScore(int val){
cout<& v){
for(vector::iterator it = v.begin();it!=v.end();it++){
//当前学生进行打分
deque dScore;
for(int i=0;i<10;i++){
int score = rand()%41+60;
dScore.push_back(score);
}
//对分数排序，默认从小到大
sort(dScore.begin(),dScore.end());
//for_each(dScore.begin(),dScore.end(),PrintScore);
//cout<::iterator dit = dScore.begin();dit!=dScore.end();dit++){
totalScore+=(*dit);
}
int aveScore = totalScore/dScore.size();
//保存分数
(*it).mScore = aveScore;
}
}
set容器
#include
#include//预定义函数对象
#include
#include
#include
using namespace std;
//初始化
void test01(){
set myset;//默认构造
set myset2(myset)//拷贝构造
}
void printSet(set& myset){
for(set::iterator it = myset.begin();it!=myset.end();it++){
cout<<*it<<" ";
}
cout< myset;//默认升序
myset.insert(4);
myset.insert(2);
myset.insert(1);
myset.insert(5);
myset.insert(2);
printSet(myset);
//删除
myset.erase(myset.begin());//删除第一个元素
myset.erase(2);//根据元素值删除
printSet(myset);
myset.erase(myset.begin();myset.end());//myset.clear();
cout<<"size:"<
class mycompare03{
public:
bool operator()(T v1,T v2){
return v1>v2;
}
};
//set容器查找
void test03(){
//函数对象
//mycompare03 mycom;
//mycom(10);//函数对象，仿函数
set> myset;//默认从小到大排序
myset.insert(4);
myset.insert(2);
myset.insert(1);
myset.insert(5);
for(set>::iterator it = myset.begin();it!=myset.end();it++){
cout<<*it<<" ";
}
cout<t2.id;
}
};
void test04(){
set myset;
Teacher t1(1,2),t2(3,4),t3(5,6);
myset.insert(t1);
myset.insert(t2);
myset.insert(t3);
for(set::iterator it=myset.begin();it!=myset.end();it++){
cout<id<<" "<age< myset;
myset.insert(10);
myset.insert(5);
myset.insert(1);
myset.insert(8);
set::iterator pos = myset.lower_bound(5); //返回大于等于5 迭代器
if (pos == myset.end()){
cout << "没有找到!" << endl;
}
else{
cout << "找到：" << *pos << endl;
}
pos = myset.upper_bound(5);
if (pos == myset.end()){
cout << "没有找到!" << endl;
}
else{
cout << "找到：" << *pos << endl;
}
pair::iterator, set::iterator> pos2 = myset.equal_range(5);
if (pos2.first == myset.end()){
cout << "meiyouzhaodao!" << endl;
}
else{
cout << "zhaodao!" << *(pos2.first) << endl;
}
if (pos2.second == myset.end()){
cout << "meiyouzhaodao!" << endl;
}
else{
cout << "zhaodao!" << *(pos2.second) << endl;
}
}
对组练习
#include
#include
using namespace std;
int main(){
//第一种方式 创建一个pair
pair mypair(10,"aaa");
cout< mypair2 = make_pair("aaa","bbb");
//auto mypair2 = make_pair("aaa","bbb");
cout< mypair3 = mypair;//拷贝构造
system("pause");
return EXIT_SUCCESS;
} map容器
#include
#include mutimap员工分组
#include
#include
#include 深拷贝和浅拷贝问题
#include
#include
using namespace std;
class Teacher{
public:
Teacher(char* name,int age){
int len = strlen(name)+1;
this->name = new char[len];
strcpy(this->name,name);
this->age = age;
}
//拷贝构造
Teacher(const Teacher& t){
int len = strlen(t.name)+1;
this->name = new char[len];
strcpy(this->name,t.name);
this->age = t.age;
}
//重载
Teacher& operator=(Teacher& t){
int len = strlen(t.name)+1;
if(this->name!=NULL){
delete[] this->name;
}
this->name = new char[len];
strcpy(this->name,t.name);
this->age = t.age;
return *this;
}
~Teacher(){
if(this->name!=NULL){
delete[] this->name;
}
this->age = 0;
}
char* name;
int age;
};
void test01(){
Teacher t1("aaa",20);
vector v;
v.push_back(t1);
}
int main(){
test01();
system("pause");
return EXIT_SUCCESS;
} 函数对象
#include
#include
#include
#include
using namespace std;
void print(){
cout<<"hello world"< v;
for (int i = 0; i < 10;i++){
v.push_back(i);
}
myprint04 myp04;
myprint04 myp05 = for_each(v.begin(), v.end(), myp04); //函数对象做参数
cout << "count:" << myp04.count << endl; cout << endl;
cout << "count:" << myp05.count << endl; cout << endl;
}
一元二元函数对象和一元二元谓词
#include
#include
#include
using namespace std;
//如果你写的函数对象接受一个参数，那么就叫 一元函数对象
//如果你写的函数对象接受两个参数，那么叫 二元函数对象
//如果你写的函数对象或者普通函数接受一个参数，并且返回值是Bool，叫一元谓词
//如果你写的函数对象或者普通函数接受二个参数，并且返回值是Bool，叫二元谓词
//一元函数对象 应用举例 : for_each
class print{
public:
void operator()(int v){
cout << v << " ";
}
};
void print2(int v){
cout << v << " ";
}
void test01(){
vector v;
for (int i = 0; i < 10;i++){
v.push_back(i);
}
//print p;
//for_each(v.begin(), v.end(), print()); //函数对象
for_each(v.begin(), v.end(), print2); //普通函数
cout << endl;
}
//一元谓词 应用举例：find_if
class mycompare{
public:
bool operator()(int v){
if (v > 7){
return true;
}
else{
return false;
}
}
};
void test02(){
vector v;
for (int i = 0; i < 10; i++){
v.push_back(i);
}
/*
template inline
_InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)
{ // find first satisfying _Pred
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Pred);
return (_Rechecked(_First,
_Find_if(_Unchecked(_First), _Unchecked(_Last), _Pred)));
}
template inline
_InIt _Find_if(_InIt _First, _InIt _Last, _Pr _Pred)
{ // find first satisfying _Pred
for (; _First != _Last; ++_First)
if (_Pred(*_First))
break;
return (_First);
}
*/
vector::iterator pos = find_if(v.begin(), v.end(), mycompare()); //匿名函数对象
if(pos == v.end()){
cout << "没找到" << endl;
}
else{
cout << "找到:" << *pos << endl;
}
}
//二元函数对象 应用举例 : transform
class myplus{
public:
int operator()(int v1,int v2){
return v1 + v2;
}
};
void test03(){
vector v1,v2,v3;
for (int i = 0; i < 10; i++){
v1.push_back(i);
v2.push_back(i + 1);
}
/*
template inline
_OutIt transform(_InIt1 _First1, _InIt1 _Last1,
_InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
{ // transform [_First1, _Last1) and [_First2, ...) with _Func
_DEBUG_RANGE(_First1, _Last1);
_DEBUG_POINTER(_Dest);
_DEBUG_POINTER(_Func);
if (_First1 != _Last1)
return (_Transform2(_Unchecked(_First1), _Unchecked(_Last1),
_First2, _Dest, _Func,
_Is_checked(_Dest)));
return (_Dest);
}
template inline
_OutIt _Transform(_InIt1 _First1, _InIt1 _Last1,
_InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
{ // transform [_First1, _Last1) and [_First2, ...) with _Func
for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
*_Dest = _Func(*_First1, *_First2);
return (_Dest);
}
*/
v3.resize(v1.size());
for_each(v1.begin(), v1.end(), print2); //普通函数
cout << endl;
for_each(v2.begin(), v2.end(), print2); //普通函数
cout << endl;
for_each(v3.begin(), v3.end(), print2); //普通函数
cout << endl;
transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), myplus()); //匿名函数对象
cout << "------------------------------" << endl;
for_each(v1.begin(), v1.end(), print2); //普通函数
cout << endl;
for_each(v2.begin(), v2.end(), print2); //普通函数
cout << endl;
for_each(v3.begin(), v3.end(), print2); //普通函数
cout << endl;
}
//二元谓词 应用举例 : sort
class mycompare04{
public:
bool operator()(int v1,int v2){
return v1 > v2; //从大到小
}
};
void test04(){
vector v;
v.push_back(5);
v.push_back(2);
v.push_back(7);
v.push_back(9);
/*
template inline
void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
{ // order [_First, _Last), using _Pred
_DEBUG_RANGE(_First, _Last);
_DEBUG_POINTER(_Pred);
_Sort(_Unchecked(_First), _Unchecked(_Last), _Last - _First, _Pred);
}
*/
for_each(v.begin(), v.end(), print2); //普通函数
cout << endl;
sort(v.begin(), v.end(), mycompare04());
for_each(v.begin(), v.end(), print2); //普通函数
cout << endl;
}
int main(){
//test01();
//test02();
//test03();
test04();
system("pause");
return EXIT_SUCCESS;
}
预定义函数对象
#include
#include
#include
#include
#include
using namespace std;
/*
template T plus//加法仿函数
template T minute//减法仿函数
template T multiplies//乘法仿函数
template T divides//除法仿函数
template T modulus//取模仿函数
template T negate//取反仿函数
*/
void test01(){
plus myplus;
int ret = myplus(10,20);
cout< myplus2;
string s1 = "aaa";
string s2 = "bbb";
string ret2 = myplus2(s1,s2);
cout<()(10,20)< v1,v2,v3;
for(int i=0;i<10;i++){
v1.push_back(i);
v2.push_back(i+1);
}
v3.resize(v1.size());
//plus myplus;
for_each(v3.begin(),v3.end(),print);
cout<());
for_each(v3.begin(),v3.end(),print);
cout<