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类对象s1 string s2("hello bit"); // 用C格式字符串构造string类对象s2 string 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 one
value_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)
