c++中级STR

分享一些c++案例

str简介

//STL中容器，算法，迭代器
/*容器:置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来
常用的数据结构:数组，链表，数，栈，队列，集合，映射表等
序列式容器和关联度容器
序列式容器:强调值的排序，序列式容器中每个元素均有固定的位置
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
算法:问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法
算法分为:质变算法或非质变算法。
质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换
删除等等
非质变算法:是指运算过程中不会更改区间内的元素内容，例如查找，
计数，遍历，寻找极值等等
迭代器:容器和算法之间黏合剂
提供一种算法，使之能够依序寻访某个容器所含的各个元素，
而又无需暴露该容器的内部表达方式。
每个容器都有自己专属的迭代器
迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器
为指针。
迭代器种类:
输入迭代器:对数据只读访问
输出迭代器:对数据只写访问
前向迭代器:读写操作，并能前向推进迭代器
双向迭代器:读写操作，并能向前和向后操作
随机访问迭代器:读写操作，可以以跳跃的方式访问任意数据，
功能最强迭代器。

容器算法迭代器初识

//容器算法迭代器初识
/*STL中最常用的容器为vector，可以理解为数组。
vector存放内置数据类型
容器:vector
算法:for_each
迭代器:vector<int>::iterator*/
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>//标准算法头文件
//victor容器存放内置数据类型
void myPrint(int val)
{
   
	cout<<val<<endl;
}
void test01()
{
   
	//创建了一个vector容器，数组
	vector<int>v;
	
	//向容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	
/*	//通过迭代器访问容器中的数据
	vector<int>::iterator itBegin=v.begin();//起始迭代器 指向容器中
	//第一个元素
	vector<int>::iterator itEnd=v.end();//结束迭代器 指向容器中最后
	//一个的下一个位置
	
//第一种遍历方式
	while (itBegin != itEnd)
	{
		cout<<*itBegin<<endl;
		itBegin++;
	}*/
/*	//第二种遍历方式
	for(vector<int>::iterator it =v.begin();it!=v.end();it++)
	{
		cout<<*it<<endl;
	}*/
//	第三种遍历方式 利用STL提供遍历算法
	for_each(v.begin(),v.end(),myPrint);
}
int main()
{
   
	test01();
	system("pause");
	return 0;
}

容器中存放自定义类型

#include <iostream>
using namespace std;
#include<vector>
#include<string>
//vector容器中存放自定义数据类型
class Person
{
   
	public:
	Person(string name,int age)
	{
   
		this->m_Name=name;
		this->m_Age=age;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
   
	vector<Person>v;
	Person p1("aaa",10);
	Person p2("bbb",20);
	Person p3("ccc",30);
	Person p4("ddd",40);
	Person p5("eee",50);
	//向容器中添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	//遍历容器中的数据
	for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
	{
   
	//	cout<<"姓名: "<<(*it).m_Name<<" 年龄"<<(*it).m_Age<<endl;
			cout<<"姓名: "<<it->m_Name<<" 年龄"<<it->m_Age<<endl;
	}
}
//存放自定义数据类型 指针
void test02()
{
   
	vector<Person*>v;
	Person p1("aaa",10);
	Person p2("bbb",20);
	Person p3("ccc",30);
	Person p4("ddd",40);
	Person p5("eee",50);
	//向容器中添加数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);
	//遍历容器
	for(vector<Person*>::iterator it=v.begin();it!=v.end();it++)
	{
   
		cout<<"姓名:"<<(*it)->m_Name<<"年龄:"<<(*it)->m_Age<<endl;
	}
}
int main()
{
   
//	test01();
	test02();
	system("pause");
	return 0;
}

简单评委打分

/*有五名选手:选手ABCDE，10个评委分别对每一名选手打分
去除最高分，去除最低，取平均分
1.创建五名选手，放入vector容器中
2.遍历vector容器，取出来每一名选手，执行for循环，可以把十个评分
   打分存放到deque容器中
3.sort算法对deque容器中分数排序，去除最高和最低分
4.deque容器遍历一遍，累加总分
5.获取平均分*/
#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
using namespace std;
//选手类
class Person
{
   
	public:
	Person(string name,int score)
	{
   
		this->m_Name=name;
		this->m_Score=score;
	}
	string m_Name;
	int m_Score;
};
void creatPerson(vector<Person>&v)
{
   
			string nameSeed="ABCDE";
	for(int i=0;i<5;i++)
	{
   
		string name="选手";
		name+=nameSeed[i];
		int score=0;
		Person p(name,score);
		//将创建的person 对象 放入到容器中
		v.push_back(p);
	}
}
int main()
{
   
	//创建5名选手
	vector<Person>v;//存放选手容器
	creatPerson(v);
	//测试
	for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
	{
   
		cout<<"姓名为"<<it->m_Name<<"分数为"<<it->m_Score<<endl;
	}
	//给5名选手打分
	
	//3.显示最后得分
	system("pause");
	return 0;
}

容器嵌套容器

#include <iostream>
using namespace std;
#include<vector>
//容器镶套容器
void test01()
{
   
	vector<vector<int>>v;
	//创建小容器
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;
	//向小容器中添加数据
	for(int i=0;i<4;i++)
	{
   
		v1.push_back(i+1);
		v2.push_back(i+2);
		v3.push_back(i+3);
		v4.push_back(i+4);
	}
	//将小容器中插入到大容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	//通过大容器，把所有数据遍历一遍
	for(vector<vector<int>>::iterator it =v.begin();it != v.end();it++)
	{
   
		//(*it)---容器 vector<int>
		for(vector<int>::iterator vit=(*it).begin();vit!=(*it).end();vit++)
		{
   
			cout<<*vit<<" ";
		}
		cout<<endl;
	}
}
int main()
{
   
	test01();
	system("pause");
	return 0;
}

map容器的插入和删除

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<ctime>
using namespace std;
void printMap(map<int,int>&m)
{
   
	for(map<int,int>::iterator it=m.begin();it!=m.end();it++)
	{
   
		cout<<"key="<<it->first<<"value="<<it->second<<endl;
	}
	cout<<endl;
}
//map容器的插入和删除
void test01()
{
   
	map<int,int>m;
	//插入
	//第一种
	m.insert(pair<int,int>(1,10));
	//第二种
	m.insert(make_pair(2,20));
	//第三种
	m.insert(map<int,int>::value_type (3,30));
	//弟四种
	m[4]=40;
//	cout<<m[4]<<endl;
printMap(m);
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);
printMap(m);
m.erase(m.begin(),m.end());
printMap(m);
}
int main()
{
   
	test01();
	system("pause");
	return 0;
}

map容器的查找和统计

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<ctime>
using namespace std;
//map容器中的查找和统计
void test01()
{
   
	//查找
	map<int,int>m;
	m.insert(pair<int,int>(1,10));
	m.insert(make_pair(2,20));
	m.insert(pair<int,int>(3,30));
	m.insert(pair<int,int>(4,40));
	map<int,int>::iterator pos=m.find(3);
	if(pos!=m.end())
	{
   
		cout<<"查到了元素key="<<pos->first<<"value="<<(*pos).second<<endl;
	}
	else
	{
   
		cout<<"没有查找到"<<endl;
	}
	
	
	//统计
	int num=m.count(3);
	cout<<"num="<<num<<endl;
}
int main()
{
   
	test01();
	system("pause");
	return 0;
}

容器排序

#include <iostream>
/*#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>*/
#include<map>
//#include<ctime>
using namespace std;
class MyCompare
{
   
	public:
	bool operator()(int v1,int v2)
	{
   
		//降序
		return v1>v2;
	}
};
//map容器 排序
void test01()
{
   
	map<int,int,MyCompare>m;
	
	m.insert(make_pair(1,10));
	m.insert(make_pair(2,20));
	m.insert(make_pair(3,30));
	m.insert(make_pair(4,40));
	m.insert(make_pair(5,50));
	for(map<int,int,MyCompare>::iterator it=m.begin();it!=m.end();it++)
	{
   
		cout<<"key="<<it->first<<"value="<<it->second<<endl;
	}
}
int main()
{
   
	test01();
	system("pause");
	return 0;
}

string基本概念

/*  3.1.1  string基本概念
本质
string是c++风格的字符串，而string本质上是一个类
string 和char*区别
1.char*是一个指针
2.string 是一个类，类内部封装了char*,管理这个字符串，是一个
  char*型容器。
 特点
 string 类内部封装了很多成员方法
 如:查找find,拷贝copy,删除delect,替换replace,插入insert
 string 管理char*所分配的内存，不用担心复制越界和取值越界
 等，由类内部负责
 3.1.2 string构造函数
 构造函数原型
 string();创建一个空的字符串 例如:string str;
 string(const char*s);//使用字符串s初始化
 string(const string& str)//使用一个string对象初始化另一个
                 string 对象
 string(int n,char c) ;//使用n个字符c初始化*/
 #include <iostream>
using namespace std;
#include<string>
//string的构造函数
void test01()
{
   
	string s1;//默认构造;
	const char *str="hello world";
	string s2(str);
	cout<<"s2="<<s2<<endl;
	string s3(s2);
	cout<<"s3="<<s3<<endl;
	string s4(10,'a');
	cout<<"s4="<<s4<<endl;
}
int main()
{
   
	test01();
	system("pause");
	return 0;
}

string赋值

/*3.1.3string 赋值操作
功能描述:
给string字符串进行赋值
赋值的函数原型
1.string& operator=(const char* s);//char*类型字符串 赋值给当前的
      字符串
2.string& operator=(const string &s);//把字符串s赋值给当前的字符串
3.string& operator=(char c);//字符赋值给当前的字符串
4.string& assign(const char*s);//把字符串s赋值给当前的字符串
5.string& assign(const char* s,int n);//把字符串s的前n个字符赋
       给当前的字符串
6.string& assign(const string &s);//把字符串s赋给当前字符串
7.string& assign(int n,char c);//用n个字符c赋给当前字符串*/
#include <iostream>
using namespace std;
#include<string>
void test01()
{
   
	string str1;
	str1="hello world";
	cout<<"str1="<<str1<<endl;
	string str2;
	str2=str1;
	cout<<"str2="<<str2<<endl;
	string str3;
	str3='a';
	cout<<"str3="<<str3<<endl;
	string str4;
	str4.assign("hello c++");
		cout<<"str4="<<str4<<endl;
	string str5;
	str5.assign("hello c++",5);
	cout<<"str5="<<str5<<endl;
	string str6;
	str6.assign(str5);
	cout<<"str6="<<str6<<endl;
	string str7;
	str7.assign(10,'w');
	cout<<"str7="<<str7<<endl;
}
int