C++ string和vector

string基本内容

#include<iostream>
#include<string>
using namespace std;
int main(){
	//string对象的读写
	string s;
	cin>>s;
	//读取并忽略开头所有的空白字符
	//读取字符直至再次遇到空白符 读取中止
	//输入hello world得到的将会是hello
	//读取位置数目的string对象
	string s;
	while(cin>>s)
		cout<<s<<endl;
	//用getline读取整行文本
	string line;
	//知道getline遇到换行符就停止读入并返回 如果第一个字符就是换行符那么string参数将被置为空string
	while(getline(cin,line))
		cout<<line<<endl;
	//由于Line不含换行符 所以需要自行添加
	//getline会丢弃换行符
	 
}

string对象操作

//string对象的操作有
string s;
s.empty();
s.size();
s[n];
s1+s2;
s1=s2;
v1==v2;
!=,<,<=,>,>=;
//string的size和empty操作
//empty()成员函数将返回bool值，如果string对象为空则返回true 否则返回false
//size()返回一个的是一个string::size_type类型的值
//string类类型和许多其他库一样都定义了一些配套类型 通过这些 配套类型，库函数的使用就和机器无关
//任何存储string的size操作结果的变量必须为string::size_type类型 特别重要的是不要把size的返回值赋给一个int变量
//由于范围问题 所以保存一个string size对象的最安全的方法就是使用标准库类型 string::size_type
//string关系操作符
string big="big",small="small";
string s1=big;//s1是big的副本
if(big==small)
//。。。
if(big<=s1)
//就和strcmp很类似的判断机制
//string 对象的赋值
string s1,s2="wdsdsd";
s1=s2;
//这样s1就是一个包含s2所有字符的副本

//两个string对象相加
string s1,s2,s3;
cin>>s1>>s2; 
s3=s1+s2;//把两个字符串连接起来
//如果要把s2字符串追加到s1末尾 可以用+=字符串
s1+=s2;
//也可以
s1+=",";
//和字符串字面值的连接

//从string对象获取字符
//下标操作符需要一个 size_type类型的值，来表明要访问字符的位置，这个下表中的值通常被称为 下表 或 索引
//string对象的下标从0开始。如果s是一个string对象且s不空，那s[0]就是第一个字符，s[1]是第二个字符
//s[s.size-1]是最后一个字符 如果超出下标表示范围就会引起溢出错误
//下表操作可用作左值 
for(string::size_type ix=0;ix!=str.size();++ix)
	str[ix]='*';
//计算下标值  

标准vector学习

#include<vector>
using std::vector;
//vector是一个类模板，使用模板可以编写一个类定义或函数定义
 
 //vector对象的定义和初始化
 vector<T> v1;//vector保存类型为T的对象。默认构造函数v1为空 
 vector<T> v2(v1);//v2是v1的一个副本
 vector<T> v3(n,i)l// v3包含n个值为i的元素
 vector<T> v4(n); //v4含有值初始化的元素的n个副本
//创建非空的vector对象 必须给出初始化元素的值 
//当把一个vector对象复制到另一个vector对象时 新复制的vector中每一个元素都初始化为原vector 中相应元素的副本。
//但这两个vector对象必须保存同一种元素类型 
vector<int> ivec1;
vector<int> invec2(ivec1);
vector<string> sevc(ivec1);//错误 不同类型
//
vector<int> ivec4(10,-1);//10个 -1
vector<string> svec(10,"hi!");

//vector对象动态增长
//vector对象的重要属性就是在于运行时可以高效的添加元素	因为vector增长的效率高 在元素已知的情况下
//最好是动态地添加元素 

vector对象操作

v.empty() //如果v为空 返回true 否则返回false
v.size()  //返回v中元素的个数
v.push_back(t)//在v的末尾添加一个元素 t 
v[n] //返回v中位置为n的元素
v1=v2 //v1中的元素替换为v2中元素的副本
v1==v2//如果v1v2相等 返回true
!=....
//vector对象的size 
//empty和size操作类似于string类型的相关操作 成员函数size返回应该是vector类定义的size_type
//使用size_type类型时 必须指出该类型时在哪里定义的 vector类型总是包括vector的元素类型
//使用size_type类型时必须指出这个类型是在哪里定义的
vector<int>::size_type //ok
vector::size_type//error
//向vector添加元素
//push_back() 操作接受一个元素值 把它作为一个新元素添加在尾部 也就是push到back
string word;
vector<string> text;
while(cin>>word){
	text.push_back(word);
} 
//vector的下标操作
//vector中的对象是没有命名的  可以按vector中对象的位置来访问他们 通常使用下标操作符来获取元素
//类似于string
for(vector<int>::size_type ix=0;ix!=ievc.size();ix++){
	..... 
} 

//上例中 即使ievc 为空for循环也会正确执行
//下标操作不添加元素
vector<int> ivec;
for(vector<int>::size_type ix=0;ix!=10;ix++){
	ivec[ix]=ix;
} 
//其实不然
//正确写法应该是 
vector<int> ivec;
for(vector<int>::size_type ix=0;ix!=10;ix++){
	ivec.push_back(ix);
} 
//必须是已存在的元素才能哟弄个下标操作符进行索引，通过下表操作进行赋值时不会添加任何元素
//仅能对已存在的元素进行下标操作
//下面给出错误例子
vector<int> ivec;
cout<<ivec[0];//empty vector
			 //Error ivec has no elements!

vector<int> ivec2(10);
cout<<ivec[10];//Error ivec has elements 0...9
//试图获取不不存在的元素必然产生运行时错误 而且这个结果是不确定的
//不幸的是...
 基本迭代器

//vector除了下标访问 还有一种访问方式 迭代器(iterator
//容器的 iterator
vecto<int>::iterator iter;
// 每个容器都定义了自己的迭代器类型

//begin 和end 操作
//每种容器都定义了一对名为begin和end 的函数，用于返回迭代器 如果容器中有元素的话
//由begin返回的迭代器指向第一个元素
vector<int>::iterator iter=ivec.begin();
//上述语句执行完之后 若ievc不空iter指向的元素为ivec[0]
//由end操作返回的迭代器指向vector的“末端元素的下一个” 通常称为超出末端迭代器（off-the-end iterator
//表明它指向了一个不存在的元素，如果vector为空 begin和end 返回的迭代器相同


//vector迭代器的自增和解引用运算
//迭代器类型可以使用解引用运算符 来访问迭代器所指向的元素
*iter=0 ;
++iter;

//迭代器的其他操作
//对于两个迭代器的比较可以用== !=这两个操作符来比较迭代器

//迭代器应用的程序示例
for(vector<int>::size_type ix=0;ix!=ivec.size();++ix){
	ivec[ix]=0;
} 
//假设已经声明了一个vector<int>类型的ivec变量，要把它所有元素都置零，可以如上

//更典型的写法就是迭代器来编写循环
for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();iter++)
	*iter=0;

//const_iterator
//前面的程序用vector::iterator改变vector中的元素值 每种容器类型还定义了一种叫做const_iterator的类型 
//该类型只能用于读取容器内元素 但不能改变其值
//当我们对const_iterator解引用时 可以得到一个指向const 对象的引用 如同任何常量以一样我们不能改变他的值 该对象不能重写
//如果text是vector<string>类型 程序员想要遍历它 输出每个元素 可以这样： 
for(vector<string>::const_iterator iter=text.begin();iter!=text.end();iter++)
	cout<<*iter<<endl;
//使用const_iterator类型时，我们可以得到一个迭代器，它自身的值可以改变 但是不能用来改变所指向元素的值
//可以使用解引用 但是不能对改元素赋值

//但是不要把const_iterator和const iterator混淆
vector<int> nums(10);//nums is nonconst
const vector:iterator cit=nums.begin();
*cit=1;//ok!
cit++;//error!
//单纯加上const限定符之后 只能改变所指向的元素的值 但是不能改变其本身 无法指向其他任何元素

//迭代器的算术操作
iter+n;
iter-n;

iter1-iter2;
//用来计算两个迭代器都想的距离 该距离是名为difference_type的signed类型的值
vector<int>::iterator mid=vi.begin()+vi.size()/2;
//上述代码用来初始化mid 使其指向vi中最靠近正中间的元素 

vector<int> nums(10);
for(vector<int>::iterator it=nums.begin(); it!=nums.end();it++)
	....;