C++字符串

一、C风格字符串

1.1字符串常量

"cstring";
const char*cstr = "cstring";    
//C风格字符串在存储时会在末尾自动添加一个'\0'

1.2字符串变量，C风格字符串实际是以空字符null('\0')结束的字符数组，char*

//可以先声明字符数组，再逐个元素赋值，包括末尾的'\0'
char cstr1[3];
cstr1[0] = 'h';
cstr1[1] = 'i';
cstr1[2] = '\0';
//可以声明同时初始化，数组长度不能小于字符串的长度+1，可以不显式指定数组长度，由编译器确定
char cstr2[6] = "Hello";    //不用加'\0'
char cstr2[6] = {'H','e','l','l','o','\0'};    //要加'\0'
char cstr2[] = "Hello";
char cstr2[] = {'H','e','l','l','o','\0'};
//C++11
char cstr3[]{ "hello" };
char cstr3[] = { "hello" };    //等号多此一举

1.3输入字符串

cin >> cstr;    //>>不能读入空白符（空格、Tab、回车等）
//cin也会将换行符保留在输入队列中，所以混合输入字符串和数字也会有问题，
//例如先输入数字，输入队列中会保留'\n'，导致后面的字符串输入失败，
//可以在读取字符之前加一句cin.get()，消耗掉换行符

cin.get(cstr,n);
//至多把n-1个字符读入cstr，并自动添加'\0'
//结束条件：遇到换行符且丢弃换行符 或读入的字符数达到n-1。
//默认结束标志是换行符，可以通过第3个参数来指定其他字符作为结束符标志

cin.getline(cstr,n);
//同上，但是会将换行符保留在输入队列中，为避免后面的输入被忽略，可以再加一句cin.get()，消耗掉换行符

1.4输出字符串

cout << cstr;    //<<会输出从cstr开始的字符，直到遇见'\0'

1.5cstring库

size_t strlen(cstr);
//返回一个无符号整数，表示str的长度，不包括'\0'
//区别：sizeof(cstr)，返回数据类型对应的存储字节数，包括'\0'，返回值类型为size_t

char* strcpy(strDest,strSrc);
//将strSrc(包括'\0')复制到strDest所占据的内存块中，并返回strDest的基址

char* strncpy(strDest,strSrc);
//将strSrc的前n个字符复制到strDest所占据的内存块中，并返回strDest的基址
//注意strDest第n个字符后面要再补充一个'\0'

char* strcat(strDest,strSrc);
//将strSrc(包括'\0')连接到strDest的结尾处(原来的'\0'去掉)，并返回strDest的基址

char* strncat(strDest,strSrc);
//将strSrc的前n个字符连接到strDest的结尾处(原来的'\0'去掉)，连接后的strDest会添加一个'\0'，并返回strDest的基址。
//如果strDest可连接的字符刚好n个，而strSrc的n个字符非空，则strDest的末尾将没有'\0'

int strcmp(str1,str2);
//将str1和str2自左向右逐个字符按ASCII值大小比较，直到出现第一对不同的字符或遇到'\0'
//str1>str2，返回str1-str2（某些编译器返回1）;str1<str2，返回str1-str2（某些编译器返回-1）;str1==str2，返回0

int strncmp(str1,str2);
//将str1和str2的前n个字符自左向右逐个字符按ASCII值大小比较，直到出现第一对不同的字符或达到n个字符或遇到'\0'
//str1>str2，返回str1-str2（某些编译器返回1）;str1<str2，返回str1-str2（某些编译器返回-1）;str1==str2，返回0

char* strchr(s1, ch);
//返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。

char* strstr(char*str1,const char*str2);
//返回模式串str1在主串str2中的位置

1.6cstdlib库

double atof(cstr);    //返回double类型值
int atoi(cstr);    //返回int类型值
long atol(cstr);    //返回long类型值
//这些函数将忽略起首的空白字符；当字符串以数字起首时，会忽略位于数字后面的非数字符号，只处理数字；
//如果字符串不能转为数值，返回0；如果超过能表示的范围，则返回一个极大或极小的数值

1.7cctype库

bool isalpha(char);
bool isupper(char);
bool islower(char);
bool isdigit(char);
bool isxdigit(char);    //十六进制数字
bool isalnum(char);
char toupper(char);
char tolower(char);
bool isspace(char);    //是否空格字符、制表符、换行符或formfeed符？
bool isctrl(char);    //是否控制字符
bool ispunct(char);    //是否标点符号
bool isprchar(char);    //是否可打印字符
bool isgraph(char);    //是否可显示字符

1.8char cstr[], const char* cstr,  const char cstr[]的区别

char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char* str5 = "abc";
const char* str6 = "abc";
cout << (str1 == str2) << endl; //0
cout << (str3 == str4) << endl; //0
cout << (str5 == str6) << endl; //1
//为了节省内存，C/C++把字符串常量放到单独的一个内存区域，当几个指针赋值给相同的常量字符串时，它们会指向相同的内存地址。
//但用常量初始化数组时，会首先分配合适的内存空间，并把常量字符串的内容分别复制到数组中。

二、string

#include <string>
using namespace std;
// using std::string;

1.string类的构造函数：

//构造函数原型
string();    //默认构造函数，构造长度为0的string对象
string(const char*s);    //将string对象初始化为s指向的cstring
string(const string &str);    //复制构造函数，将string对象初始化为string对象str
string(size_type n, char c);    //创建一个包含n个字符c的string对象
string(const char*s, size_type n);    //将string对象初始化为s指向的cstring的前n个字符,如果超过了csting的结尾，会补充乱码（烫烫烫烫）
string(const string &str, string size_type pos = 0, size_type n = npos);    //将string对象初始化为对象str中从pos开始到结尾的字符，或从pos开始的n个字符
template<typename Iter>
string(Iter begin, Iter end);    //将string对象初始化为区间[begin,end)内的字符，注意左闭右开
string(string && str)noexcept;    //将string对象初始化为string对象str，并可能修改str（移动构造函数）
string(initializer_list<char> il);    //将string对象初始化为初始化列表il中的字符

//构造函数实例
char cstr[12] = "hello world";
string str1();        //默认构造函数创建str1对象
string str2(cstr);    //用cstr初始化str2对象
string str3(str2);    //复制构造函数创建str3对象
string str4(8, '$');    //将str4初始化为包含8个'$'字符的对象
string str5(cstr, 10);    //将str5初始化为cstr的前10个字符
string str6(cstr, 20);    //将str6初始化为cstr的所有字符，剩余空位用无用字符补齐
string str7(str6, 3);    //将str7初始化为str6的前3个字符
string str8(str6, 3, 5);    //将str7初始化为str6从位置3开始的5个字符
string str9(cstr + 2, cstr + 9);    //将str9初始化为cstr[2:8]
string str10(&str9[2], &str9[5]);    //将str10初始化为cstr9[2:4]
string str11(str10);    //移动复制构造函数创建str11对象，str10可变
string str12 = { 'h','e','l','l','o' };    //初始化列表初始化对象str12
string str13{ 'w','o','r','l','d' };    //初始化列表初始化对象str13
string str14 = "hello world";
string str15 = str14;

1.2输入字符串

cin>>str;    //>>不能读入空白符（空格、Tab、回车等）
getline(cin,str)；//输入整行字符，包括初始和中间的空白，直到遇见换行符，这里不能指定长度，可以指定第三字符作为结束标记

1.3输出字符串

cout<<str;    //string类重载了<<操作符

1.4string类常用方法

size_t length();    //获得字符串的长度,取值范围0~npos
size_t size();    //获得字符串的长度,取值范围0~npos
size_t capcity();    //返回当前分配给字符串的内存块大小

string substr(size_t pos=0,size_t len=npos)const;
//从str的pos位置开始（包括pos位置），获取最多len个字符的子串，然后返回一个临时的string对象.pos：0~length-1

size_t find(const char* cstr, size_t pos=0)const;
size_t find(const string&str, size_t pos=0)const;
//在str中查找子串cstr/str,返回值类型为string::size_type；
//若找到，返回值为arg在str中第一次出现的位置；若找不到，返回npos
size_t find(char ch, size_t pos=0)const;
size_t find(const char* cstr, size_t pos=0, sizt_t n)const;

//其他类似方法
//rfind(),find_first_of(),find_last_of(),find_first_not_of(),find_last_not_of()

str.c_str();    //string对象转换成C风格字符串，返回C风格字符串的基址，用途：ifstream对象的成员函数open只能接受C风格字符串作为文件名
string filename;
ifstream infile;
cin >> filename;
infile.open(filename.c_str()); 

append();    //在字符串的末尾添加字符
insert();    //插入字符
replace();    //替换字符串
string& erase(size_t pos=0, size_t len=npos);    //删除从pos位置开始的len个字符

reverse(str.begin(), str.end());    //反转字符串，reverse()是标准库函数

//字符串的比较，用重载的>  >=  < <=   ==   !=运算符，规则同cstring，但返回值只有true和false
//字符串连接，用重载的+运算符，str3=str1+str2;

1.5获取字符串单个字符

str[n]    使用str[n]方式，程序员/用户需要自己保证n的正常取值，系统不作任何检查
str.at(n)     使用str.at(n)方式比较安全，因为当n取值在正常范围以外时，系统会产生一个例外（“索引超出范围”的错误），并终止程序

三、string、const char*、char*的转换

1. string转const char* 

string str = "abc"; 
const char* cstr = s.c_str(); 

2. const char* 转string

const char* cstr = "abc"; 
string str(ctrs); 

3. string 转char* 

string s = "abc"; 
char* ctr; 
ctr = new char[s.length()+1]; 
strcpy(ctr,str.c_str()); 

4. char* 转string 

char* cstr = "abc";     //新标准不允许这样赋值
string str(cstr); 

5. const char* 转char* 

const char* kCstr = "abc"; 
char* cstr = new char[strlen(kcstr)+1]; 
strcpy(cstr,kCstr); 

6. char* 转const char*

char* cstr = "abc";    //新标准不允许这样赋值
const char* kCstr = cstr;