c++字符串string操作全解

#pragma once                  //防止文件被多重包含
#include <stdio.h>
#include <stdlib.h>
#include <string>             //字符串
#include <iostream>           //数据流
#include <memory>             //内存操作
#include <regex>              //正则表达式
#include <chrono>             //正则表达式   vs2012后有

using namespace std;


int main()
{
	string strlp="luanpeng";
	char* charlp = "luanpeng";
	char chararrlp[] = "luanpeng";

	//char*和char[]转str，直接赋值
	strlp=charlp;
	strlp=chararrlp;

	//str转char*
	const char* charlp1 = strlp.data();   //data返回不带\n，c_str返回带\n。
	strcpy(charlp,strlp.c_str());  //c_str()并不新建内存，c_str()和data只能转换为const的变量。strcpy为c语言复制内存函数

	//str转char[]
	char p[5];
	strlp.copy(p,2,1);  //2表示赋值的长度，1表示开始位置
	p[2]='\n';   //手动添加'\n'


}

//字符串转化大小写
string lower(string str)
{
	transform(str.begin(),str.end(),str.begin(),tolower);
	return str;
}

//字符串转化大小写
string upper(string str)
{
	transform(str.begin(),str.end(),str.begin(),toupper);
	return str;
}

//去除字符串的首尾
void trim_string(string &s)     //字符串去除首尾
{  
	if (!s.empty())   
	{  
		s.erase(0,s.find_first_not_of(" "));  
		s.erase(s.find_last_not_of(" ") + 1);  
	}
}

//按字符分割字符串
void split_char(const std::string& yuan, std::vector<std::string>& arr, const std::string& split)   //多字符分割
{
	std::string::size_type pos1, pos2;
	pos2 = yuan.find_first_of(split);
	pos1 = 0;
	while(std::string::npos != pos2)
	{
		if (pos1!=pos2)
			arr.push_back(yuan.substr(pos1, pos2-pos1));
		pos1 = pos2 + 1;
		pos2 = yuan.find_first_of(split, pos1);   //find_first_of方法查询任意一个字符首次出现的位置，允许了使用多个分割字符
	}
	if(pos1 != yuan.length())  //分割剩余的最后一个字符串
		arr.push_back(yuan.substr(pos1));
}

//按字符串分割字符串
void split_string(const std::string& yuan, std::vector<std::string>& arr, const std::string& split)   //字符串分割
{
	std::string::size_type pos1, pos2;
	pos2 = yuan.find(split);
	pos1 = 0;
	while(std::string::npos != pos2)
	{
		if (pos1!=pos2)
			arr.push_back(yuan.substr(pos1, pos2-pos1));
		pos1 = pos2 + split.size();
		pos2 = yuan.find(split, pos1);   //find_first_of方法查询任意一个字符首次出现的位置，允许了使用多个分割字符
	}
	if(pos1 != yuan.length())
		arr.push_back(yuan.substr(pos1));
}

//替换全部子字符串
void  replace_string(string&   str,const   string&   old_value,const   string&   new_value)   
{   
	for(string::size_type   pos(0);   pos!=string::npos;   pos+=new_value.length())   {   
		if(   (pos=str.find(old_value,pos))!=string::npos   )   
			str.replace(pos,old_value.length(),new_value);   
		else   break;   
	}   
}

//字符串长度
int length(string& str)
{
	return str.length();
}

//连接两个字符串,每个字符串最右边的空格被裁切 
string strcat(string& a,string& s) 
{
	string aa = a;
	string ss=s;
	aa.erase(aa.find_last_not_of(" ") + 1);  
	ss.erase(ss.find_last_not_of(" ") + 1);  
	return aa+ss;
}

//比较字符串是否相等
bool strcmp(string& a,string& b)
{
	if (a==b)
		return true;
	return false;
}

//比较字符串前n个字符相等
bool strncmp(string& a,string& b,int n)
{
	string aa=a.substr(0,n);
	string bb=b.substr(0,n);
	if (aa==bb)
		return true;
	return false;
}

//比较字符串是否相等，不区分大小写
bool strcmpi(string& a,string& b)
{
	string aa=lower(a);
	string bb=lower(b);
	if (aa==bb)
		return true;
	return false;
}

//比较字符串前n个字符相等，不区分大小写
bool strncmpi(string& a,string& b,int n)
{
	string aa=a.substr(0,n);
	string bb=b.substr(0,n);
	aa=lower(aa);
	bb=lower(bb);
	if (aa==bb)
		return true;
	return false;
}

//检测字符串中每个字符时否属于英文字母 
bool isletter(string& a)
{
	for (int i=0;i<a.length();i++)
	{
		if(a[i]<'a' || a[i]>'Z')
			return false;
	}
	return true;
}

//检测字符串中每个字符是否属于格式字符（空格，回车，制表，换行符等） 
bool isspace(string& a)
{
	for (int i=0;i<a.length();i++)
	{
		if(a[i]!=' ' && a[i]!='\n' && a[i]!='\t' && a[i]!='\r')
			return false;
	}
	return true;
}

//删除结尾空格
void deblank(string& a)
{
	a.erase(a.find_last_not_of(" ") + 1);  
}

//裁切字符串的开头和尾部的空格，制表，回车符
void strtrim(string& str)
{
	trim_string(str);
}

//替换子串
string strrep(string s,string& sub,string& replace)
{
	replace_string(s,sub,replace);
	return s;
}

//分割字符串成两段
string* strtok(string s,char split)
{
	string* p=new string[2];
	std::string::size_type pos1=s.find(split);
	if (pos1==std::string::npos)
	{
		p[0]=s;
		p[1]="";
	}else
	{
		p[0]=s.substr(0,pos1);
		p[1]=s.substr(pos1+1);
	}
	return p;

}

//创建有n个空格组成的字符串 
string blanks(int n)
{
	string p="";
	for(int i=0;i<n;i++)
		p=p+" ";
	return  p;
}

//查找str1和str2中，较短字符串在较长字符串中出现的位置，没有出现返回空数组 
vector<int> findstr(string& s,string& sub)
{
	vector<int> all;
	std::string::size_type pos1=s.find(sub);
	if (pos1!=std::string::npos)
	{
		all.push_back(pos1);
		pos1=s.find(sub);
	}
	return all;
}

//将数字转换为数字字符串 
string num2str(double value)
{
	return to_string(value);
}

//把数值数组转换为整数数字组成的字符数组 
string int2str(int value)
{
	return to_string(value);
}

//将数字字符串转换为数字 
double str2num(string str)
{
	return stod(str);
}