C++primer 第九章：顺序容器----字符串

练习9.43：编写一个函数，接受三个string参数s,oldVal 和 NewVal。使用迭代器及insert 和 erase 函数将s中所有的oldVal 替换成newVal；

一.想法

1. 使用循环遍历s，并查找s中是否包含oldVal字符串，并用标记变量flag标记，包含flag=TRUE，否则 flag =FALSE

2.如果flag=True，说明包含指定字符串；此时需要执行删除和替换操作；

易出错的地方：在对字符串s执行删除，替换操作时；会使原先指向s的迭代器失效，因此我们需要重置迭代器；

 s 的erase操作时，会使指向string中删除点之后的迭代器失效；

s的 insert 操作时，会使指向string中所有的迭代器失效；

二. 代码

string ReplaceString(string s,string oldValue,string newValue)
{
	auto iters = s.begin();
	auto iters_1=iters;
	bool flag=false;
	while (iters!= s.end())
	{
		auto iterOld = oldValue.begin();
		auto iterNew = newValue.begin();
		if (*iters == *iterOld)      //判断第一个元素是否相同
		{
		    iters_1 = iters;  //记录第一个相同的位置
			if(1==oldValue.size())
			{
				flag=true;
				iters_1++;  //使迭代器指向我们要删除的元素的之后的位置
			}
			else
			{
	
				iters_1++;              //指向下一个元素
				iterOld++;

				while (iterOld!=oldValue.end())
				{
					if (*iters_1!=*iterOld)
					{
						flag=false;
						//continue;
						break;       //跳出当前while循环
					}
					++iters_1;
					++iterOld;
					flag=true;
				}
			}
			
		}
		if (flag==true) //找到匹配的字符
		{
			//执行替换操作,先删除在插入
			flag=false;
			iters = s.erase(iters,iters_1);
			
			//注：向string插入元素，会使所有指向容器的迭代器，引用，指针失效；
			iters=s.insert(iters,newValue.begin(),newValue.end());
			iters+=newValue.size();
		}
		else
		++iters;  //指向下一个元素
	}
	return s;
}</span>

函数讲解：

（1）s.erase(b,e)    

功能：删除迭代器b和e指定范围内的元素；b指向第一个要删除的元素，e指向最后要删除的元素的下一个位置；

返回值：返回最后一个被删除的元素之后元素的迭代器；

（2）s.insert(p,b,e)

功能：将迭代器b，e指定范围内的元素插入到迭代器p所指定的元素之前；其中b，e不能指向s中的元素

返回值：返回新添加的第一个元素的迭代器；范围为空则返回p；

假设：s=abchkdhjk ； oldVal=chk ； newVal = rwqa；按照题目要求，我们分两步走，先删除，再插入，从而完成了替换；

在调用erase函数之后，即 iters = s.erase(iters,iters_1);语句之后，s=abdhjk ；此时iters指向字母d ；

然后调用insert函数，即iters=s.insert(iters,newValue.begin(),newValue.end()); ，在iters指向的元素d之前插入了newValue字符串，此时指向s的iters迭代器失效，因此我们需要重置iters； 在调用insert函数之后，s=abrwqadhjk, 此时insert函数的返回值iters指向字符r，这不是我们想要的结果，我们想要iters指向字符d，因为前面的字符我们已经处理过了就不用再处理了；因此，才有了iters+=newValue.size();这句代码，执行这句代码之后iters指向元素d；

迭代器：

（1）迭代器提供了对对象的间接访问；

（2）string s;  

auto b = s.begin()  auto e = s.end();   b指向s的第一个元素，e指向s的最后一个元素的下一个位置；

auto 是C++11标准新增加的关键字，可以由编译器自动判断变量的类型；

迭代器的范围由一对迭代器表示，这种元素范围被称为左闭合区间:[begin,end)

（3）迭代器类型

标准库使用 iterator 和 const_iterator 来表示迭代器的标准类型

vector<int>::iterator it; //it能读写ivector<int>中的元素

string::iterator it;  //it能够读写string对象中的字符

vector<int>const_iterator it;   //it 只能读ivector<int>中的元素

(4)  解引用与成员访问

     *it  ---解引用　　　(*it).empty()  ---- 成员访问           it->empty()  ----相当于把解引用和成员访问结合在一起；

(5)

auto iters = s.begin();
while (iters!= s.end()){  }

使用迭代器写一个while循环，一般用上述格式，而不要用一个变量保存尾迭代器，

     即auto e=s.end(), while(iters!=e){}  这样可能得到你想不到的结果，因为在循环体内，可能会对容器进行一些操作，会使迭代器失效；

下面是使用下标和replace  函数实现上述函数

string ReplaceString(string s,string oldValue,string newValue)
{
	string::size_type OVindex,NVindex,pos=0;
	bool flag=false;
	//主循环
	for (string::size_type index = 0;index != s.size();++index)
	{
		OVindex=0;
		NVindex=0;
		//查找字符是否存在
		if (s[index]== oldValue[OVindex])
		{
			pos=index;  //记录匹配起始位置
			string::size_type cpIndex=index;
			if (oldValue.size()==1)
			{
				flag=true;
				
			}
			else
			{
				++cpIndex;
				++OVindex;
				while (OVindex!=oldValue.size())
				{
					if (s[cpIndex] != oldValue[OVindex] )
					{
						flag=false;
						break;
					}
					++cpIndex;
					++OVindex;
					flag=true;
				}
			}
		}
		//处理
		if (flag==true)
		{
			flag=false;
			s.replace(pos,oldValue.size(),newValue);
			index+=newValue.size()-1;

		}
	}
	return s;
}

函数：是string对象拥有的

s.replace(range,args)

range:表示一个范围　　可以是一个下标和一个长度　或者一对指向ｓ的迭代器；

args:指定的字符

功能：删除指定范围的字符，替换为args指定的字符；

返回值：一个指向s的引用；