一、初识string类
1.string类（了解）
1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作
单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信
息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits
和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
总结：
1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;
4. 不能操作多字节或者变长字符的序列。
在使用string类时，必须包含#include头文件以及using namespace std;
2.string类接口
1.string类对象的默认成员函数
| 函数名称 | 功能说明 |
| constructor | 构造函数 |
| destructor | 析构函数 |
| operator= | 赋值重载 |
string s1;
string s2("hello world");
string s3 = s2; //已经内置了operator=了，可以直接用上
string s4(s2); //可以用作拷贝
cout << s1 << endl;
cout << s2 << endl << s3 << endl << s4 << endl;
string s5(s2, 1, 6); //从s2下标1开始到6
cout << s5 << endl;
string s6(s2, 1); //从s2下标1开始到尾
cout << s6 << endl;
string s7(s2, 1, 100); //从s2下标1到100，但是超过了字符串长度的时候一直到尾
cout << s7 << endl;
string s8("hello world", 7);//注意这个首坐标是从1开始的！！
cout << s8 << endl;
string s10(10,'x'); //打印10个x的字符
cout << s10 << endl;
//下面注意不能反过来！！不然会出现错误（不会报错）
/*string s11('x', 10);
cout << s11 << endl;*/
s1 = s2; //可以赋值，有operator=
cout << s1 << endl;
s1 = "love";
cout << s1 << endl;
s1 = 'x';
cout << s1 << endl;2.string类对象的常见容量操作
| 函数名称 | 功能说明 |
| size | 返回字符串有效字符长度 |
| lenth | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| maxsize | 返回字符串的最大长度 |
| clear | 清空有效字符 |
| empty | 检测字符串释放为空串，是返回true，否则返回false |
| reverse | 为字符串预留空间 |
| rsize | 将有效字符的个数该成n个，多出的空间用字符c填充 |
注意：
1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
string s1("hello world");
//下面的size和length都不会算到'\0'的
cout << s1.size() << endl;
cout << s1.length() << endl;
for (int i = 0; i < s1.size(); i++)
{
cout << s1[i] << " ";
cout << s1.operator[](i) << " ";
}
cout << endl;
//还可以改变字符
s1[0] = 'x';
cout << s1 << endl;
//string给逆置下
cout << "逆置之前的s1：" << s1 << endl;
size_t begin = 0, end = s1.size() - 1;
while (begin < end)
{
char tmp = s1[begin];
s1[begin] = s1[end];
s1[end] = tmp;
++begin;
--end;
}
cout << "逆置之后的s1：" << s1 << endl;
//其实C++内部已经有swap()的函数的了，再也没必要继续搞的了，这样方便很多！
cout << "swap()逆置之前的s1：" << s1 << endl;
begin = 0, end = s1.size() - 1;
while (begin < end)
{
/*char tmp = s1[begin];
s1[begin] = s1[end];
s1[end] = tmp;*/
swap(s1[begin], s1[end]);
++begin;
--end;
}
cout << "swap()逆置之后的s1：" << s1 << endl;
cout << endl;
//iterator用法像指针
string::iterator it = s1.begin();
while (it != s1.end())
{
/**it += 1;*/
cout << *it << " ";
++it;
}
cout << endl;
//其实C++中也有逆置函数reverse()!!又方便了很多了！
reverse(s1.begin(), s1.end());
cout << s1 << endl;下面是对于字符串的增扩容问题
string s1("hello world");
cout << s1.size() << endl;
cout << s1.capacity() << endl;
cout << s1 << endl;
//> capacity时，为 扩容+尾插
s1.resize(100, 'x');
cout << s1.size() << endl;
cout << s1.capacity() << endl;
cout << s1 << endl;
cout << "------------------" << endl;
//size < n < capacity 可以作为尾插
string s2("hello world");
cout << s2.size() << endl;
cout << s2.capacity() << endl;
cout << s2 << endl;
s2.resize(12);
cout << s2.size() << endl;
cout << s2.capacity() << endl;
cout << "------------------" << endl;
//n < size -> 删除数据，保留前n个
string s3("hello world");
cout << s3.size() << endl;
cout << s3.capacity() << endl;
cout << s3 << endl;
s3.resize(7);
cout << s3.size() << endl;
cout << s3.capacity() << endl;
cout << s3 << endl;3.string类对象的访问及遍历操作
| 函数名称 | 功能说明 |
| operator[] | 返回pos位置的字符，const string类对象调用 |
| begin + end | begin获取第一个字符的迭代器 + end获取最后一个字符下一个位置的迭代器 |
| rbegin + rend | rbegin获取最后一个字符的迭代器 + rend获取第一个字符前一个位置的迭代器 |
| 范围for | C++11支持更简洁的范围for的新遍历方式 |
下面是operator的底层
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}以及begin和范围for的用法
//iterator用法像指针
string::iterator it = s1.begin();
while (it != s1.end())
{
/**it += 1;*/
cout << *it << " ";
++it;
}
cout << endl;
//其实C++中也有逆置函数reverse()!!又方便了很多了！
reverse(s1.begin(), s1.end());
cout << s1 << endl;
//类似存储顺序表的用vector
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
vector<int>::iterator vit = v.begin();
while (vit != v.end())
{
cout << *vit << " ";
++vit;
}
cout << endl;
list<double> lt;
lt.push_back(1.1);
lt.push_back(2.1);
lt.push_back(3.1);
lt.push_back(4.1);
list<double>::iterator lit = lt.begin();
while (lit != lt.end())
{
cout << *lit << " ";
++lit;
}
cout << endl << endl;
//用 范围for才是yyds!!!!
for (auto e : s1)
{
cout << e << " ";
}
cout << endl;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
for (auto e : lt)
{
cout << e << " ";
}
cout << endl;4.string类对象的修改操作
| 函数名称 | 功能说明 |
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+=() | 在字符串后追加字符串str |
| insert | 在指定位置插入字符或字符串等操作 |
| erase | 删除字符串中的一部分 |
| replace | 替换指定区间的字符串 |
下面以代码示例各种用法
void test4()
{
//push_back 和 append的用法
string s1("hello");
s1.push_back(' ');
s1.append("world");
s1.append(3,'x');
cout << s1 << endl;
string s2 = "xxxx";
const string& s3 = "xxxx";
s2.append(++s1.begin(), --s1.end());
cout << s2 << endl;
// += 的用法
s1 += '!';
s1 += "xxxxx";
cout << s1 << endl;
}
//insert的用法
void test5()
{
string s1("[hello world]");
s1.insert(0, 3, 'w');//从0位置头插3个字符:'w'
cout << s1 << endl;
s1.insert(0, "20231122"); //从0位置头插一个字符串
cout << s1 << endl;
cout << "----------------" << endl;
string s("[hello world]");
s.insert(2, "0123456789", 3, 4);//在s串的下标为2的位置开始插入一个子串
//这个子串是"0123456789"的从下标为3的位置开始,长度为4的子串:也就是3456
cout << s << endl;
}//erase
void test6()
{
string s("0123456789");
s.erase(3, 4);//从3号下标位置开始删除4个字符,也就是删除了3456
cout << s << endl;
s.erase(2);//默认从2号下标开始的删除所有字符
cout << s << endl;
s.erase();//默认删除所有字符
cout << s << endl;
}void test7()
{
cout << "-----replace-------" << endl;
string s1("ABCDEFGHI");
string s2("abcdefghi");
s1.replace(2, 3, s2);
cout << s1 << endl;//把s1的从下标为2位置开始长度为3的字符替换为字符串s2
//也就是把CDE替换为abcdefghi
s2.replace(s2.begin() + 2, s2.begin() + 4, "------");
//把s2的[2,4)区间内的字符(也就是cd)替换为"------"
cout << s2 << endl;
}5.string类对象的其他字符串操作
| 函数名称 | 功能说明 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
| find | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置 |
| find_first_of | 从前往后找第一个匹配的字符 |
| find_last_of | 从后往前找第一个匹配的字符 |
| find_first_not_of | 从前往后找第一个不匹配的字符 |
| find_last_not_of | 从前往后找第一个不匹配的字符 |
二.string类的模拟
class string
{
public:
// 构造函数
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
memcpy(_str, str, _size + 1);
}
//s1(s2)
string(const string& s)
{
_str = new char[s._capacity + 1];
memcpy(_str, s._str, s._size);
_capacity = s._capacity;
_size = s._size;
}
//这个【c_str】就是string类的对象转换成为字符串
//那么我们知道对于字符串而言与流插入<<是有重载的，所以才可以起到一个很好地匹配
const char* c_str()
{
return _str;
}
//s1 = s3
//版本1
/*string& operator=(const string& s)
{
if (this != &s)
{
char* tmp = new char[s._capacity + 1];
memcpy(tmp, s._str, s._size);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}*/
//版本2（pua）
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_capacity, s._capacity);
std::swap(_size, s._size);
}
/*string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);
this->swap(tmp);
}
return *this;
}*/
//版本3（终极）
string& operator=(string tmp)
{
this->swap(tmp);
return *this;
}
//operator[]可读可写
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
//operator[]可读不可写
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
//iterator迭代器
//而对于迭代器而言我们也是要去实现两种，一个是非const的，一个则是const的
typedef char* iterator;
typedef const char* const_iterator;
//这里的话我就实现一下最常用的【begin】和【end】
//首位的话就是_str所指向的这个位置，而末位的话则是_str + _size所指向的这个位置
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const iterator begin() const
{
return _str;
}
const iterator end() const
{
return _str + _size;
}
//Capacity
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
bool empty()
{
return _size == 0;
}
// 扩容(修改_capacity)
void reserve(size_t newCapacity = 0)
{
// 当新容量大于旧容量的时候，就开空间
if (newCapacity > _capacity)
{
// 1.以给定的容量开出一块新空间
char* tmp = new char[newCapacity + 1];
// 2.将原本的数据先拷贝过来
memcpy(tmp, _str, _size);
// 3.释放旧空间的数据
delete[] _str;
// 4.让_str指向新空间
_str = tmp;
// 5.更新容量大小
_capacity = newCapacity;
}
}
/*
如果这个 newSize < _size 的话，那我们要选择去删除数据
如果这个 newSize > _size，但是呢 newSize < _capacity 的话，此时要做的就是新增数据但是呢不去做扩容
如果这个 newSize > _size 的话，我们便要选择去进行扩容了
*/
void resize(size_t newResize, char c = '\0')
{
if (newResize > _size)
{
if (newResize > _capacity)
{
reserve(newResize);
}
memset(_str + _size, c, newResize - _size);
}
_size = newResize;
_str[newResize] = '\0';
}
//push_back
void push_back(char c)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size++] = c;
_str[_size] = '\0';
}
//append
void append(const char* s)
{
size_t len = strlen(s);
if (_size + len > _capacity)
{
reserve(_size + len);
}
// 将字符串拷贝到末尾的_size位置
memcpy(_str + _size, s, len + 1);
_size += len;
}
/*
operator+=(char ch)
首先的话是去【+=】一个字符，这里我们直接复用前面的push_back()接口即可
最后因为【+=】改变的是自身，所以我们return *this，那么返回一个出了作用域不会销毁的对象
可以采取 引用返回 减少拷贝
*/
string& operator+=(char c)
{
push_back(c);
return *this;
}
//operator+=(const char* s)
//而对于【 += 】一个字符串，我们则是去复用前面的append()即可
const string& operator+=(const char* s)
{
append(s);
return *this;
}
//insert
//从pos位置开始插入n个字符
void insert(size_t pos, size_t n, char ch)
{
assert(pos <= _size);
if (_size + n > _capacity)
{
reserve(_size + n);
}
size_t end = _size;
while (end >= pos && end != npos)
{
_str[end + n] = _str[end];
--end;
}
for (size_t i = 0; i < n; i++)
{
_str[pos + i] = ch;
}
_size += n;
}
//从pos位置开始插入一个字符串
void insert(size_t pos, const char* s)
{
size_t len = strlen(s);
assert(pos <= _size);
if (_size + len > _capacity)
{
reserve(_size + len);
}
size_t end = _size;
while (end >= pos && end != npos)
{
_str[end + len] = _str[end];
--end;
}
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = s[i];
}
_size += len;
}
//erase
void earse(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len + pos >= npos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
//find
/*
从pos位置开始找指定的字符
这个很简单，就是去遍历一下当前对象中的_str
若是在遍历的过程中发现了字符ch的话就返回这个位置的下标
如果遍历完了还是没有找到的话就返回npos这个最大的无符号数
*/
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;
}
//从pos位置开始找指定的字符串（找子串）
/*
使用的是C语言中的库函数 strstr
如果找到了的话就会返回子串第一次出现在主串中的指针
那我们如果要去计算这个指针距离起始位置有多远的话使用指针 - 指针的方式即可
那如果没找到的话我们返回【npos】即可
*/
size_t find(const char* s, size_t pos = 0)
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, s);
if (ptr == nullptr)
return npos;
else
return ptr - _str;
}
//substr
string substr(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
size_t end = pos + len;
if (len == npos || pos + len >= npos)
end = _size;
string s;
s.reserve(end - pos);
for (size_t i = pos; i < end; i++)
{
s += _str[i];
}
return s;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
private:
size_t _size;
size_t _capacity;
char* _str;
static size_t npos;
};
size_t string::npos = -1;
// 流插入
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}
return out;
}
扫一扫
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
