标准模板库STL

最新推荐文章于 2022-06-11 02:50:01 发布

Jonny的ICU

最新推荐文章于 2022-06-11 02:50:01 发布

阅读量276

点赞数

分类专栏： c++

本文链接：https://blog.csdn.net/m0_37338590/article/details/68066111

版权

c++ 专栏收录该内容

12 篇文章 2 订阅

订阅专栏

向量：
/*
	引入该向量类的方式：
	#include<vector>
	实际上，vector是一种动态数组，是基本的数组类模板。其内部定义了许多操作，既然是一个类，那么他就会有自己的构造函数。
	vector类中定义了四种构造函数。
	1）默认构造函数：其构造函数的初始长度为0的空间向量
	vector<int> v1;
	2)有单个整形参数的构造函数，此参数描述的初始向量大小，该构造函数还有一个可选的向量参数，这是一个类型为T的实例，
	描述了各种向量成员的初始值大小，其调用如下：
	vactor<int> v2(inti_size,0)//预先定义了int inti_suze其成员函数的初始值为0；
	3)复制构造函数：构造一个新的向量，作为已存在的向量的完全复制，其调用如下：
	vector<int> v3(v2);
	4)带两个常量参数的构造函数：产生初始值作为一个区间的向量，区间由一个半开区间[first，last]（MS word的显示可能会有问题，
	First前一个左方括号，last后面是一个有圆括号）
	vector<int> v4(first,last)
	其他成员函数：
		begin(),end(),push_back(),insert(),assign(),front(),back(),erase(),empty(),at(),size()

*/

#include<vector>//STL向量的头文件，这里没有“h”
#include<iostream>

using namespace std;
char *szHW ="Hello World";
int main(/*int argc,char *argv[]*/)
{
	vector<char> vec;//声明能够一个字符向量vector（）
	vector<char>::iterator vi;//为字符数组定义一个游标，iterator
	char *cptr = szHW;
	while(*cptr !='\0')
	//初始化字符向量，对整个字符串进行循环，用来补数据填方到字符向量中，直到遇到‘\0’
	{
		vec.push_back(*cptr);
		cptr++;
	}
	for(vi=vec.begin();vi!=vec.end();vi++)
	//这是STL循环的规范化的开始——通常是“!=”而不是“<”因为“<”在一些容器中的没有定义，
	//begin()返回向量的起始元素的游标（iterator）,end()返回向量末尾元素的游标(iteraor)
	{
		cout<<*vi;
	}
	cout<<endl;
	return 0;
}

算法：

#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>

using namespace std;
class myclass{
public :
    myclass(int a,int b):first(a),second(b){}//创建带参构造函数，分别为first和second赋值
    int first;
    int second;
    bool operator<(const myclass &m) const //重载运算符
    {
        return first<m.first;
    }
};
bool less_second(const myclass & m1,const myclass & m2){
    return m1.second < m2.second;
}
int main()
{
    vector<myclass> vect;
    for(int i=0;i<10;i++)
    {
        myclass my(10-i,i*3);
        vect.push_back(my);//写入向量
    }
    for(i=0;i<vect.size();i++)
        cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
    sort(vect.begin(),vect.end());//调用排序算法
    cout<<"after sorted by first:"<<endl;
    for(i=0;i<vect.size();i++)
    {
        cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
    }
    cout<<"after sorted by second:"<<endl;
    sort(vect.begin(),vect.end(),less_second);
    for(i=0;i<vect.size();i++)
    {
        cout<<"("<<vect[i].first<<","<<vect[i].second<<")\n";
    }
    return 0;
}

列表：

/*
	列表也是容器类中的一种，其所控制的长度为N的序列是以一个有着N各节点的额双向链表来存储，支持双向迭代器，其编译的头文件为：
	#include <list>
*/

#include<list>
#include<iostream>

using namespace std;

int main()
{
	list<int> l1;
	list<int>::iterator l1_iter;
	l1.push_back(20);//将对象末端插入职位20的元素
	l1.push_back(10);
	l1.push_back(30);
	cout<<"Before sorting :l1 = ";
	for(l1_iter=l1.begin();l1_iter!=l1.end();l1_iter++)
	{
		cout<<" "<<*l1_iter;
	}
	cout<<endl;
	l1.sort();
	cout<<"After sorting l1 = ";
	for(l1_iter=l1.begin();l1_iter!=l1.end();l1_iter++)
	{
		cout<<" "<<*l1_iter;
	}
	cout<<endl;
	l1.sort(greater<int>());
	cout<<"After sorting with 'greater than'operation,l1 = ";
	for(l1_iter=l1.begin();l1_iter!=l1.end();l1_iter++)
	{
		cout<<" "<<*l1_iter;
	}
	cout<<endl;
	return 0;
}

集合：

/*
	集合也是一种容器，它的特点是在集合中迭代元素值是唯一的，在集合中，所有的成员都是排列好的，如果先后往一个集中插入：
	12,2,3,123,5,65，则输出该集合是为2,3,5,65,123
*/

#include<string>
#include<set>
#include<iostream>

using namespace std;

int main(int argc,char *argv[])
{
	set<string> strset;
	set<string>::iterator si;
	strset.insert("cantaloupes");
	strset.insert("apple");
	strset.insert("organge");
	strset.insert("banana");
	strset.insert("grapes");
	strset.insert("grapes1");
	for(si=strset.begin();si!=strset.end();si++)
	{
		cout<<*si<<" ";
	}
	cout<<endl;
	return 0;
}

双端队列：

/*
	双端队列是一个queue容器类，其定义在头文件deque中，在使用该容器时，需要在头文件加上语句：
	#include<deque>
	双端队列和vector类似，支持随机访问和快速插入和删除，他在容器中某一位位置上的操作所花费的时间是线性时间
*/
#include<iostream>
#include<deque>

using namespace std;

typedef deque<int> INTDEQUE;
void put_deque(INTDEQUE deque,char *name)//从前向后显示deque队列的全部元素
{
	INTDEQUE::iterator pdeque;
	cout<<"The contents of "<< name<<" ;";
	for(pdeque=deque.begin();pdeque!=deque.end();pdeque++)
	{
		cout<<*pdeque<<" ";
	}
	cout<<endl;
}

int main()
{
	INTDEQUE deq1;
	INTDEQUE deq2(10,6);
	INTDEQUE::iterator i;//声明一个变量名为i的迭代器
	put_deque(deq1,"deq1");//从前向后显示deq1的数据
	put_deque(deq2,"deq2");//从前向后显示deq2的数据
	deq1.push_back(2);
	deq1.push_back(4);
	cout<<"deq1.push_back(2) and deq1.push_back(4):"<<endl;
	put_deque(deq1,"deq1");//显示deq1中的元素
	deq1.push_back(5);//在队列前面添加元素
	deq1.push_back(7);
	cout<<"deq1.push_back(5) and deq1.push_back(7):"<<endl;
	put_deque(deq1,"deq1");//显示deq1中的元素
	deq1.insert(deq1.begin()+1,3,9);//在队列中间插入数据元素
	cout<<"deq1.insert(deq1.begin()+1,3,9):"<<endl;
	put_deque(deq1,"deq1");
	cout<<"deq1.at(4)="<<deq1.at(4)<<endl;
	cout<<"deq1[4]="<<deq1[4]<<endl;
	deq1.at(1)=10;
	deq1[2]=12;
	cout<<"deq1.at(1)=10 and deq[2]=12 :"<<endl;
	put_deque(deq1,"deq1");
	deq1.pop_front();//从队列前移去一个元素
	deq1.pop_back();//从队列后移去一个元素
	cout<<"deq1.pop_front() and deq1.pop_back() :"<<endl;
	put_deque(deq1,"deq1");
	deq1.erase(deq1.begin()+1);//清除第二个元素
	cout<<"deq1.erase(deq1.begin()+1):"<<endl;
	put_deque(deq1,"deq1");
	deq2.assign(8,1);
	cout<<"deq2.assign(8,1):"<<endl;
	put_deque(deq2,"deq2");
	return 0;
}

栈：

/*
	容器栈是一种特殊的容器，特点：先进后出
*/

#include<iostream>
#include<stack>

using namespace std;

int main(int argc,char *argv[])
{
	const int ia_size=10;
	int ia[ia_size]={0,1,2,3,4,5,6,7,8,9};
	stack<int> intStack;
	for(int ix=0;ix<ia_size;ix++)
	{
		intStack.push(ia[ix]);//入栈操作
	}
	if(intStack.size()!=ia_size)
	{
		cout<<"error!"<<endl;
		exit(1);
	}
	int value;
	while(!intStack.empty())
	{
		value=intStack.top();//取栈顶元素
		cout<<value<<" ";
		intStack.pop();//出栈
	}
	cout<<endl;
	return 0;
}

映射和多重映射：

/*
	映射和多重映射
	#include<map>
*/

#include<map>
#include <iostream>

using namespace std;
int main(void)
{
	map<char,int,less<char> > map1;//定义变量，其中char 是键入类型，int是值类型
	map<char,int,less<char> >::iterator mapIter;//创建迭代器
	map1['c']=3;
	//初始化，与数组类似，也可以使用map.insert(map<char,int,less<char>>)::value_type("c",3);
	map1['a']=1;
	map1['d']=4;
	map1['b']=2;
	for(mapIter=map1.begin();mapIter!=map1.end();mapIter++)
	{
		cout<<" "<<(*mapIter).first<<": "<<(*mapIter).second;
		//first对应的事char键，而second对应是int值
	}
	cout<<endl;
	map<char,int ,less<char> >::const_iterator ptr;
	ptr=map1.find('d');//检索
	cout<<" "<<(*ptr).first<<"--------"<<(*ptr).second<<endl;
	return 0;
}

迭代器：

/*
	迭代器
*/
#include<iostream>
#include<fstream>
#include<iterator>//包含迭代器的头文件
#include<vector>
#include<string>

using namespace std;

int main()
{
	vector<string> v1;//定义一个向量
	ifstream file("test.txt");//打开文件
	if(file.fail())
	{
		cout<<"open file text1.txt filed"<<endl;
		return 1;
	}
	copy(istream_iterator<string>(file),istream_iterator<string>(),inserter(v1,v1.begin()));
	copy(v1.begin(),v1.end(),ostream_iterator<string>(cout," "));//复制内容
	cout<<endl;
	return 0;
}