string类
string不属于STL,早于STL出现
看文档
C++非官网(建议用这个)
C++官网
文章目录
- string类
- 一.为什么学习string类？
- 1.C语言中的字符串
- 2. 两个面试题(暂不做讲解)
- 二.标准库中的string类
- 1. string类(了解)
- 2. string类的常用接口说明（注意下面我只讲解最常用的接口）
- (1).string类对象的常见构造
- (2).string类对象的容量操作
- (3).string类对象的访问及遍历操作
- (4).string类对象的修改操作
- (5).string类非成员函数
- (6). vs和g++下string结构的说明
- (7).牛刀小试
- 三.string类的模拟实现
- 1. 浅拷贝
- 2. 深拷贝
- 3. 模拟实现String类
- 4. 写时拷贝(了解)
- 四. 扩展阅读
- 五.补充知识
一.为什么学习string类？
1.C语言中的字符串
C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
2. 两个面试题(暂不做讲解)
字符串相加
在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数。
二.标准库中的string类
1. string类(了解)
string类的文档介绍
- 字符串是表示字符序列的类
- 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
- string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
- string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
- 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
总结：
- string是表示字符串的字符串类
- 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
- string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;
- 不能操作多字节或者变长字符的序列。
在使用string类时，必须包含#include头文件以及using namespace std;
2. string类的常用接口说明（注意下面我只讲解最常用的接口）
(1).string类对象的常见构造
void Teststring() {string s1; // 构造空的string类对象s1string s2("hello bit"); // 用C格式字符串构造string类对象s2string s3(s2); // 拷贝构造s3 }
(2).string类对象的容量操作
[string容量相关方法使用代码演示](课件代码/C++课件V6/string的接口测试及使用/TestString.cpp · will/C++上课 - Gitee.com)
注意：
size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()，有效字符长度不包含’/0’(/0’是标识字符,不是有效字符)。
clear()只是将string中有效字符清空，不改变底层空间大小。
resize(size_t n) 与 **resize(size_t n, char c)**都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
-
补充①:扩容
补充②:静态分配和动态分配
补充③:清除和缩容
补充④:reverse
(3).string类对象的访问及遍历操作
-
补充知识:迭代器
[string中元素访问及遍历代码演示](课件代码/C++课件V6/string的接口测试及使用/TestString.cpp · will/C++上课 - Gitee.com)
(4).string类对象的修改操作
[string中插入和查找等使用代码演示](课件代码/C++课件V6/string的接口测试及使用/TestString.cpp · will/C++上课 - Gitee.com)
注意：
- 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
(5).string类非成员函数
cin>>str遇到空格停止,getline不会
上面的几个接口大家了解一下，下面的OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。
(6). vs和g++下string结构的说明
注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。
- vs下string的结构
string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间：- 当字符串长度小于16时，使用内部固定的字符数组来存放
- 当字符串长度大于等于16时，从堆上开辟空间
union _Bxty
{ // storage for small buffer or pointer to larger onevalue_type _Buf[_BUF_SIZE];pointer _Ptr;char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量
最后：还有一个指针做一些其他事情。
故总共占16+4+4+4=28个字节。
-
g++下string的结构
G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：-
空间总大小
-
字符串有效长度
-
引用计数
struct _Rep_base {size_type _M_length;size_type _M_capacity;_Atomic_word _M_refcount; }; -
指向堆空间的指针，用来存储字符串。
-
引用计数举例:
(7).牛刀小试
仅仅反转字母
class Solution {
public:string reverseOnlyLetters(string s) {int left=0;int right=s.size()-1;while(left<right){while(left<right && !isalpha(s[left])){left++;}while(left<right && !isalpha(s[right])){right--;}swap(s[left],s[right]);left++;right--;}return s;}
};
找字符串中第一个只出现一次的字符
class Solution {
public:int firstUniqChar(string s) {int count[26]={0};char ch;size_t n;for(auto c : s){count[c-'a']++;}for(auto c : s){if(count[c-'a']==1){ch=c;n=s.find(ch);return n;}}return -1;}
};
字符串里面最后一个单词的长度
#include <iostream>
#include <string>
using namespace std;int main()
{string str;// 不能用cin>>str遇到空格就结束了getline(cin, str);size_t n=str.rfind(' ');if(n!=string::npos){cout<<(str.size()-n-1);}else {cout<<str.size();}return 0;
}
验证一个字符串是否是回文
class Solution {
public:bool isPalindrome(string s) {string str;string rstr;char c;for(int i=0;i<s.size();i++){if((s[i]>='a'&&s[i]<='z')||(s[i]>='0'&&s[i]<='9')){str+=s[i];}else if(s[i]>='A'&&s[i]<='Z'){c=tolower(s[i]);str+=c;}}if(s.empty())return true;rstr=str;reverse(rstr.begin(),rstr.end());if(str.compare(rstr)==0){return true;}return false;}
};
字符串相加
class Solution {
public:string addStrings(string num1, string num2) {int end1=num1.size()-1,end2=num2.size()-1;// 进位int next=0;string retstr;while(end1>=0 || end2>=0){int val1=end1>=0?num1[end1--]-'0':0;int val2=end2>=0?num2[end2--]-'0':0;int ret=val1+val2+next;next=ret/10;ret=ret%10;//retstr.insert(0 , 1 , ret+'0');retstr.push_back(ret+'0');}if(next==1){//retstr.insert(0 , 1 , '1');retstr.push_back('1');}reverse(retstr.begin(),retstr.end());return retstr;}
};
-
翻转字符串II：区间部分翻转
class Solution { public:string reverseStr(string s, int k){int n = s.size();int pos = 0;if (s.size() <= k){reverse(s.begin(), s.end());return s;}if (s.size() <= 2 * k && s.size() > k){reverse(s.begin(), s.begin() + k);return s;}while (n > 2 * k){reverse(s.begin() + pos, s.begin() + pos + k);pos += 2 * k;n -= 2 * k;}if (n <= k){reverse(s.begin() + pos, s.end());return s;}if (n<= 2 * k && n> k){reverse(s.begin() + pos, s.begin() + pos + k);return s;}return s;} }; -
转字符串III：翻转字符串中的单词
class Solution { public:string reverseWords(string s) {int pos=0;int n=s.find(' ', pos);if(n==string::npos){reverse(s.begin(),s.end());return s;}else{reverse(s.begin(),s.begin()+n);pos=n+1;n=s.find(' ', pos);}while(n!=string::npos){reverse(s.begin()+pos,s.begin()+n);pos=n+1;n=s.find(' ', pos); }if(n==string::npos){reverse(s.begin()+pos,s.end());}return s;} }; -
符串相乘
class Solution { public:string addStrings(string num1, string num2) {int end1=num1.size()-1,end2=num2.size()-1;// 进位int next=0;string retstr;while(end1>=0 || end2>=0){int val1=end1>=0?num1[end1--]-'0':0;int val2=end2>=0?num2[end2--]-'0':0;int ret=val1+val2+next;next=ret/10;ret=ret%10;//retstr.insert(0 , 1 , ret+'0');retstr.push_back(ret+'0');}if(next==1){//retstr.insert(0 , 1 , '1');retstr.push_back('1');}reverse(retstr.begin(),retstr.end());return retstr;}string multiply(string num1, string num2) {string ret="0";int n = num2.size();if (num1 == "0" || num2 == "0")return "0";for (int i = n - 1; i >= 0; i--){string tmp;string sum;int t = num2[i]-'0';while (t > 0){tmp = addStrings(tmp, num1);sum = tmp;--t;}int j = n - i - 1;if(j > 0){int k = pow(10,j);while (k > 1){sum = addStrings(sum, tmp);--k;}}ret = addStrings(ret, sum);}return ret; } }; -
找出字符串中第一个只出现一次的字符
string类的模拟实现}}cout<<"-1";return; }int main() {string s;getline(cin,s);firstUniqChar(s);} // 64 位输出请用 printf("%lld")
三.string类的模拟实现
1. 浅拷贝
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
就像一个家庭中有两个孩子，但父母只买了一份玩具，两个孩子愿意一块玩，则万事大吉，万一不想分享就你争我夺，玩具损坏。
可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。
2. 深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
3. 模拟实现String类
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<string.h>
#include<assert.h>namespace bit
{class string{public:typedef char* iterator;typedef const char* const_iterator;const_iterator begin() const{return _str;}const_iterator end() const{return _str + _size;}iterator begin(){return _str;}iterator end(){return _str + _size;}const char* c_str()const{return _str;}string(const char* str=""):_size(strlen(str)){_capacity=_size;_str=new char[_capacity+1];strcpy(_str, str);}// 1.现代写法string(const string& s){string tmp(s._str);swap(tmp);}// 2.传统写法//string(const string& s)//{// _str = new char[s._capacity+1];// strcpy(_str, s._str);// _size = s._size;// _capacity = s._capacity;//}// 1.现代写法string& operator=(string tmp){swap(tmp);return *this;}// 2.传统写法//string& operator=(const string& s)//{// char* tmp = new char[s._capacity + 1];// strcpy(tmp, s._str);// delete[] _str;// _str = tmp;// _size = s._size;// _capacity = s._capacity;// return *this;//}~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}size_t size()const{return _size;}size_t capacity()const{return _capacity;}char& operator[](int pos){assert(pos < _size);return _str[pos];}const char& operator[](int pos)const{assert(pos < _size);return _str[pos];}// 1. 自己版本void resize(size_t n, char ch = '\0'){if (n <= _size){_str[n] = '\0';_size = n;}else{for (int i = n; i > _size; i--){push_back('\0');}_size = n;}}// 2. 老师版本//void resize(size_t n, char ch = '\0')//{// if (n <= _size)// {// _str[n] = '\0';// _size = n;// }// else// {// reserve(n);// for (size_t i = _size; i < n; i++)// {// _str[i] = ch;// }// _str[n] = '\0';// _size = n;// }//}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n+1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}//优化版本void push_back(char ch){insert(_size, ch);}// 原始版本//void push_back(char ch)//{// // 扩容2倍// if (_size == _capacity)// {// reserve(_capacity==0?4:2 * _capacity);// }// _str[_size++] = ch;// _str[_size] = '\0';//}//优化版本void append(const char* str){insert(_size, str);}// 原始版本//void append(const char* str)//{// // 扩容// size_t len = strlen(str);// if (_size + len > _capacity)// {// reserve(_size + len);// }// //strcat(_str, str);需要找_str结尾效率低// strcpy(_str + _size, str);// _size += len;//}string& operator+=(char ch){push_back(ch);return *this;}string& operator+=(const char* str){append(str);return *this;}// 1.老师版本void insert(size_t pos, char ch){assert(pos <= _size);// 扩容2倍if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}//这种写法:// 1.end 不能用size_t类型,如果pos=0 , end减到0后会死循环// 2.必须强转pos为int,否则-1>pos(-1是size_t中最大值)/*int end = _size;while (end >= (int)pos){_str[end + 1] = _str[end];--end;}*/size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;}// 2.自己版本//void insert(size_t pos, char ch)//{// assert(pos <= _size);// if (_size == _capacity)// {// reserve(_capacity == 0 ? 4 : 2 * _capacity);// }// char* tmp = new char[_capacity];// strcpy(tmp, _str + pos - 1);// strcpy(_str + pos, tmp);// _str[pos] = ch;// ++_size;//}// 1.老师版本void insert(size_t pos, const char* str){assert(pos <= _size);// 扩容size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}size_t end = _size + len;while (end > pos + len - 1){_str[end] = _str[end - len];--end;}strncpy(_str + pos, str, len);_size +=len;}// 2.自己版本//void insert(size_t pos, const char* str)//{// assert(pos <= _size);// size_t len = strlen(str);// if (_size+len > _capacity)// {// reserve(_size + len);// }// char* tmp = new char[_capacity];// strcpy(tmp, _str + pos);// strcpy(_str + pos, str);// strcpy(_str + pos + len, tmp);// _size += len;//}void erase(size_t pos, size_t len = npos){assert(pos < _size);if (len == npos || len >= _size - pos)//不能写len + pos >= _size ,>=左边有溢出风险{_str[pos] = '\0';_size = pos;}else{strcpy(_str + pos, _str + pos + len);_size -= len;}}void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}size_t find(char ch,size_t pos=0)const{assert(pos < _size);for (size_t i = pos; i < _size; i++){if (_str[i] == ch)return i;}return npos;}size_t find(char* sub, size_t pos = 0)const{assert(pos < _size);const char* p = strstr(_str + pos, sub);if (p){return p - _str;}else{return npos;}}// 1. 老师版本string substr(size_t pos = 0, size_t len = npos){string sub;//if (len == npos || len >= _size-pos)if (len >= _size - pos){for (size_t i = pos; i < _size; i++){sub += _str[i];}}else{for (size_t i = pos; i < pos + len; i++){sub += _str[i];}}return sub;}// 2. 自己版本//string substr(size_t pos=0, size_t len = npos)//{// string s;// if (len == npos || len > _size - pos)// {// s.reserve(_size - pos+1);// strncpy(s._str, _str + pos, _size - pos);// s._size = _size - pos;// s += '\0';// }// else// {// s.reserve(len+1);// strncpy(s._str, _str + pos, len);// s._size = len;// s += '\0';// }// return s;//}void clear(){_size = 0;_str[_size] = '\0';}private:char* _str=nullptr;size_t _size=0;size_t _capacity=0;public:static const int npos;};const int string::npos = -1;void swap(string& x, string y){x.swap(y);}bool operator==(const string& s1,const string& s2){int ret = strcmp(s1.c_str(), s2.c_str());return ret == 0;}bool operator<(const string& s1, const string& s2){int ret = strcmp(s1.c_str(), s2.c_str());return ret < 0;}bool operator<=(const string& s1, const string& s2){return s1<s2||s1==s2;}bool operator>(const string& s1, const string& s2){return !(s1 <= s2);}bool operator>=(const string& s1, const string& s2){return !(s1 <= s2);}bool operator!=(const string& s1, const string& s2){return !(s1 == s2);}std::ostream& operator<<(std::ostream& out, const string& s){for (auto ch : s){out << ch;}return out;}//优化版本std::istream& operator>>(std::istream& in, string& s){s.clear();char ch;//in >> ch;//这种写法不行//c++的cin和c语言的scanf读字符时取不到空格或者换号//把空格或者换号默认为分隔符, 默认忽略掉.// 解决办法://1.c语言用getchar或者getc//2.c++用istream类里面的get// 注意: //c++不能用c语言的办法, c语言和c++的io流不是同一个, 它们各自有各自的缓冲区.(c++会做兼容, 但是还是不要用getchr)ch = in.get();char buff[128];//比s.reserve(128)好:1. 栈上开空间比堆上更快一些, 2.buff是局部变量不会一直占用空间size_t i = 0;while (ch != '\n' && ch != ' '){buff[i++] = ch;if (i == 127){s[127] = '\0';s += buff;//省的总是扩容,提高效率i = 0;}ch = in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}//原始版本//std::istream& operator>>(std::istream& in, string& s)//{// s.clear();// char ch;// //in >> ch;// //这种写法不行// //c++的cin和c语言的scanf读字符时取不到空格或者换号// //把空格或者换号默认为分隔符, 默认忽略掉.// // 解决办法:// //1.c语言用getchar或者getc// //2.c++用istream类里面的get// // 注意: // //c++不能用c语言的办法, c语言和c++的io流不是同一个, 它们各自有各自的缓冲区.(c++会做兼容, 但是还是不要用getchr)// ch = in.get();// while (ch != '\n' && ch != ' ')// {// s += ch;//总是扩容,提高效率// ch = in.get();// }// return in;//}//优化版本std::istream& getline(std::istream& in, string& s){s.clear();char ch;ch = in.get();char buff[128];size_t i = 0;while (ch != '\n'){buff[i++] = ch;if (i == 127){buff[127] = '\0';s += buff;i = 0;}ch = in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}//原始版本//std::istream& getline(std::istream& in, string& s)//{// s.clear();// char ch;// ch = in.get();// while (ch != '\n')// {// s += ch;// ch = in.get();// }// return in;//}
}
string模拟实现参考
4. 写时拷贝(了解)
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
写时拷贝
写时拷贝在读取是的缺陷
四. 扩展阅读
面试中string的一种正确写法
STL中的string类怎么了？
五.补充知识
-
问题:
- c++的cin和c语言的scanf读字符时取不到空格或者换号。把空格或者换号默认为分隔符, 默认忽略掉。
-
解决办法:
-
1.c语言用getchar或者getc
-
2.c++用istream类里面的get
-
-
注意:
- c++不能用c语言的办法, c语言和c++的io流不是同一个, 它们各自有各自的缓冲区.(c++会做兼容, 但是还是不要用getchr)
