C++字符串反转的⼏种⽅法
通过不同的⽅法，实现对所输⼊字符串的反转，可以很好地复习巩固 C++ 基础知识
/*分析过程:
  假设要使传递的字符串为常量const字符串，这样操作更加灵活，可直接传递字符串字⾯值进⾏反转，常见的解决⽅法就是，定义⼀个新的与传递过来字符串长度  相等的字符数组，然后进⾏字符串拷贝，把str字符按从左到右放置到字符数组中，然后采⽤循环来对字符数组中字符反转
*/
/*第⼀种，采⽤以上思路解法，传递为const类型C风格字符指针，返回为char*类型*/
//直接使⽤字符数组赋值
char* strrev1(const char* str)
{
  const size_t length = strlen(str);//求字符长度
  char *temp = new char[length];//新建⼀个等长度的字符数组
  strcpy(temp,str);//字符串拷贝
  for (size_t i = 0; i <= length/2; ++i)//对字符数组中的字符反转，循环执⾏条件为标识⼩于或等于字符长度⼀半
  {
    char c = temp[i];
    temp[i] = temp[length - i -1];
    temp[length - i -1] = c;
  }
  return temp;//返回反转后的字符
}
//采⽤指针操作⽅式
char* strrev2(const char* str)
{
  char* tmp = new char[strlen(str)];
  strcpy(tmp,str);
  char* ret = tmp;//⽤来最后返回数组指针
  char* p = tmp + strlen(str) - 1;
  while (p > tmp)
  {
    char t = *tmp;
    *tmp++ = *p;
    *p-- = t;
  }
  return ret;
}
//与上⼀函数基本相似，只不过本函数使⽤是移位操作改变字符指针指向
char* strrev3(const char* str)
{
  char* tmp = new char[strlen(str) + 1];
  strcpy(tmp,str);
  char* ret = tmp;
  char* p = tmp + strlen(str) - 1;
  while (p > tmp)
  {
    *p ^= *tmp;
    *tmp++ ^= *p;
    *p-- ^= *tmp;
  }
  return ret;
}
//节省⼏步，直接给新建的字符数组赋反转的值，呵呵，简单明了，只不过循环多执⾏⼏次
char* strrev4(const char* str)
{
  char * temp = new char[strlen(str)];
  for(int i = 0; i <= strlen(str); i++)
  {
    temp[i] = str[strlen(str) - i -1];
  }
  return temp;
}
不能直接反转常量字符串，因为没有定义新的字符数组,⽽是在原数组上直接进⾏字符反转，节省空间，提⾼效率，还要传递字符长度，增加限制，但总归是个思路)
char* strrev5 (char* str,int len)
{
  if (len <= 1)
    return str;
  char t = *str;
  *str = *(str + len -1);
  *(str + len -1) = t;
  return (strrev5(str + 1,len - 2) - 1);
}
/*如果传递是std::string类型字符串且是const的!!
  返回类型为std::string
*/
std::string strrev6(const std::string str)
{
  string r ;//定义⼀个新的字符串变量,⽤来接收
  string r;
  for(int i = 0; i < str.length(); ++i)
  {
    r = str[i] + r;//注意顺序
  }
  return r;
}
/*如果传递是std::string类型字符串，但不是const的!!
  返回类型为std::string，那你将不必再定义⼀个新的字符串变量
  节省空间，注意:string类型可以直接接受字符串字⾯值就是啦..
*/
std::string strrev6(std::string str)
{
  for(int i = 0; i <= str.length()/2; ++i)
  {
    char c = str[i];
    str[i] = str[str.length() - i -1];
    str[str.length() - i - 1] = c;
    }
  return str;
}
string类常⽤的构造函数有:
string str;        //⽣成⼀个空字符串
string str ("ABC")  //等价于 str="ABC"<br>
string str ("ABC", strlen)  // 将"ABC"存到str⾥，最多存储前strlen个字节
string s("ABC",stridx,strlen)  //将"ABC"的stridx位置，做为字符串开头，存到str⾥.且最多存储strlen个字节.
string s(strlen, 'A')  //存储strlen个'A'到str⾥
string类常⽤的成员函数有:
str1.assign("ABC");        //清空string串，然后设置string串为"ABC"
str1.length()；                //获取字符串长度
str1.size();            //获取字符串数量，等价于length()
str1.capacity();          //获取容量，容量包含了当前string⾥不必增加内存就能使⽤的字符数
str1.swap(str2);              //替换str1 和 str2 的字符串
str1.puch_back ('A');      //在str1末尾添加⼀个'A'字符，参数必须是字符形式
str1.append ("ABC");      　//在str1末尾添加⼀个"ABC"字符串，参数必须是字符串形式
str1.insert ("ABC",2);      //在str1的下标为2的位置，插⼊"ABC"
str1.clear();              //删除所有
  str1.assign("HELLO");                  //str1="HELLO"
  str1.assign("HELLO", 4);                //str1="HELL" ，只保留4个字符
  str1.assign("HELLO", 2, 3);            //str1="LLO"    ，从位置2开始，只保留3个字符
  str1.assign(5, 'c');                    //str1="CCCCC"            //按字符赋值
const char* c_str();
返回⼀个常量C字符串, 内容与本string串相同.
注意：当本string的内容改变，或被析构后，返回的字符串也不会被改变，因为返回的字符串是从新通过new char[]出来.参考下⾯代码，可以发现返回的C字符串地址和string⾥的字符串地址完全不同:
string* str = new string("ASD"); //str="ASD"
const char* c = str->c_str();
cout<<c<<endl;                //打印 : "ASD"
printf("&c[0]=%p,&str[0]=%p\n",&c[0],&str[0]);
//打印:c=0x94bf024,&str[0]=0x94bf008
str->append("dd");            //str="ASDdd"
cout<<c<<endl;                //打印 : "ASD"
delete str;                  //调⽤析构
cout<<c<<endl;              //打印 : "ASD"
反转相关(位于头⽂件<algorithm>)
string str("hello");
reverse(str.begin(),d());
cout<< str <<endl;              //反转⾃⾝字符串，打印olleh
查相关:
string str("ABCDEFGABCD");                      //11个字符
int n;<br>
/*查成功返回位置，查失败，则n等于-1*/
/*find()：从头查某个字符串*/
n= str.find('A');              //查"A",n=0;
n= str.find("AB");            //查"AB",n=0;
n= str.find("BC",1);          //从位置1处，查"BC",n=1;
n= str.find("CDEfg",1,3);      //从位置1处，查"CDEfg"的前3个字符，等价于str.find("CDE",1),n=2;
/*rfind()：反向(reverse)查，从末尾处开始，向前查*/
n= str.rfind("CD");          //从位置10开始向前查,n=9
n= str.rfind("CD",5);        //从位置5开始向前查,n=2
n= str.rfind("CDEfg",5,3);    //等价于str.rfind("CDE",5);      ，所以n=2
/
* find_first_of ()：查str⾥是否包含有⼦串中任何⼀个字符*/
n= str.find_first_of("abcDefg");    //由于str位置3是'D'，等于"abcDefg"的'D'，所以n=3
n= str.find_first_of("abcDefg",1,4); //等价于str. find_first_of ("abcD",1); 所以n=3
/* find_last_of ()：末尾查, 从末尾处开始，向前查是否包含有⼦串中任何⼀个字符*/
n= str.find_last_of("abcDefg");      //由于str末尾位置10是'D'，所以n=10
n= str.find_last_of("abcDefg",5,4);  //等价于str. find_last_of ("abcD",5); 所以n=3
/* find_first_not_of ()：匹配⼦串任何⼀个字符，若某个字符不相等则返回str处的位置，全相等返回-1*/
n= str.find_last_not_of("ABC");    //由于str位置3'D'，在⼦串⾥没有，所以 n=3
n= str.find_last_not_of("aABDC");  //由于str位置4 'F'，在⼦串⾥没有，所以 n=4
n= str.find_last_not_of("aBDC");  //由于str位置0 'A'，在⼦串⾥没有，所以 n=0
<br>
/
* find_last_not_of ()：反向匹配⼦串任何⼀个字符，若某个字符不相等则返回str处的位置，全相等返回-1*/
n= str.find_last_not_of("aBDC");  //由于str位置7'A'，在⼦串⾥没有，所以 n=7
拷贝相关:
str2=str1.substr(2);        //提取⼦串，提取出str1的下标为2到末尾，给str2
str2=str1.substr(2,3);    //提取⼦串，从 str1的下标为2开始，提取3个字节给str2 const char *s1= str.data();  //将string类转为字符串数组，返回给s1
<br>
char *s=new char[10];
⽐如:  "abcdefg" 循环右移3位等到: "efgabcd"
代码如下:
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
string operator >>(const string& str,int n)
{
string ret;
n %= str.length();
ret=str.substr(str.length()-n);              //到右移的字符串
ret+=str.substr(0,str.length()-n);
return ret;
}
int main()
{
string str="abcdefg";
string ret= str>>3 ;
cout<<ret<<endl;
return 0;
}
实例2，通过string类实现字符串反转
⽐如: "we;tonight;you" -> "ew;thginot;uoy"
代码如下:
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
using namespace std;
string reverse_func(const string& str)
{
int end;
int start=0;
int len;
string ret="";
string tmp;
while(1)
{
end=str.find(';',start);
if(end== -1)          //没到;
{
len=str.length()-start;
tmp=str.substr(start,len);
reverse(tmp.begin(),d());  //反转字符串
ret+=tmp;
return ret;
}
else              //到;
{
len=end-start;
tmp=str.substr(start,len);
reverse(tmp.begin(),d());    //反转字符串
ret+=tmp+';';
start=end+1;
}
}
}
int main()
{
string str("we;tonight;you");
string ret=reverse_func(str);
cout<< ret<<endl;
return 0;
}
练习题：
要求：⽤string完成。题⽬如下：
int main()
{
cout << reverse("", ';') << endl;                // 输出：空字符串
字符串转数组charcout << reverse(";", ';') << endl;                // 输出：;
cout << reverse("abcde;", ';') << endl;          // 输出：edcba;
cout << reverse("we;tonight;you", ';') << endl;  // 输出：ew;thginot;uoy
return 0;
}
参考代码与思路：
我们观察，reverse（“”，‘;'）函数需要传递‘;'，说明可能需要查传⼊的字符串是否有 ‘；'，查阅资料得到：
string 类中的确有find 成员函数的，它的⽤法如下：
find()：在⼀个字符串中查⼀个指定的单个字符或字符数组。如果到，就返回⾸次匹配的开始位置；如果没有查到匹配的内容，就返回string::npos。
1.如果是string：：npos 输出空字符串
2.如果到了‘；'，⽽且是在位置1，输出；字符串
3.find_last_of()：在⼀个⽬标串中进⾏查，返回最后⼀个与指定字符组中任何字符匹配的字符位置。如果没有查到匹配的内容，则返回npos。
4.逆转
5.查到第⼀个后继续往后查，若count值=2；记录；的位置
6.取以；为分割的⼦串，对每个字串逆序。
7.逆序:⼆分交换，或者⽤算法模板begin: end
到此这篇关于C++字符串反转的⼏种⽅法的⽂章就介绍到这了，更多相关C++字符串反转内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。