文章目录
- string类的介绍
- string类的常用接口介绍
- 构造相关
- 无参构造
- 字符串构造
- 拷贝构造
- 容量相关的接口
- size
- reserve
- resize
- capacity
- empty
- clear
- 数据访问及遍历相关的接口
- operator[]
- begin + end
- rbegin + rend
- 修改数据相关的接口
- push_back
- operator+=
- insert
- erase
- c_str
- find + npos
- substr
- string相关的运算符重载
- operator >>
- operator <<
- 构造相关
- string类的模拟实现(含各类接口)
string类的介绍
string是STL标准库提供的一个处理字符串的模板类，是我们学习STL必不可少的一项。
string类的常用接口介绍
构造相关
无参构造：
作用：当需要一个空字符串时可以使用这个构造来实现，string s1；
字符串构造：
作用：可以使用常量字符串的方式来构造一个string对象，如string s2(“hello world”)；
拷贝构造：
作用：可以用一个已经存在的string对象来进行拷贝初始化对象，如string s3(s2)；
容量相关的接口
size：
作用：获取string对象中字符串的长度。
reserve：
作用：为string对象中字符串申请n个空间。
resize：
作用：将string对象中字符串的有效字符改为n个，如果n小于当前的size，就会截取前n个，但实际的空间容量大小不会发生改变，如果n大于当前的size，就会产生扩容，也可以指定填充字符C，指定后扩容的部分会填充为C，不指定默认是空字符。
capacity：
作用：返回对应string对象中字符串的空间总大小。
empty：
作用：检查对象中字符串是否为空串，是返回true，否则返回false。
clear：
作用：清空string对象中字符串的有效字符，并不会改变其空间大小。
数据访问及遍历相关的接口
operator[]：
作用：string类中对 [ ] 进行了重载，所以可以让我们用下标的方式来进行访问数据，并且会对数组越界进行检查，返回值是pos位置的字符的引用，可以修改，下面的是const对象使用的 [ ] ，const对象的返回值不能修改。
begin + end：
begin作用：获取string对象中字符串的第一个字符的迭代器
end作用：获取string对象中字符串的最后一个字符的下一个位置的迭代器
注意：
1、迭代器是STL中通用的遍历容器方式，迭代器是一种行为像指针一样的类型，但是迭代器的底层实现是不是指针不确定，具体看容器的底层实现方式，迭代器的使用方式也很像指针，迭代器++就是访问当前位置的下一个数据，- -(自减)就是前一个。
2、第二个const接口是提供给const对象调用的，普通的对象和const对象的迭代器是不一样的，不能混淆，因为const迭代器是不允许通过迭代器来修改数据的。
rbegin + rend：
rbegin作用：获取string对象中字符串的最后一个字符的反向迭代器
rend作用：获取string对象中字符串的第一个字符的前一个位置的反向迭代器
注意：反向迭代器是把字符串中的数据反过来进行遍历，反向迭代器的rbegin就是字符串中的尾元素，rend就是字符串中的头元素的前一个位置，对于反向迭代器++是访问当前元素的前一个，- -(自减)是访问后一个。
修改数据相关的接口
push_back：
作用： 在string对象的字符串中尾插一个字符c。
operator+=：
作用： string类中重载的一个+=运算符，可以在字符串尾部追加一个字符串，上面三个接口依次代表追加一个string对象、一个字符串、一个字符，这三个接口使用非常频繁，很重要。
insert：
作用：这个接口稍微复杂，可以在数组中pos位置插入字符、字符串、string对象、字符串子串，其中1-4接口是插入字符串或者string对象，5-7接口是通过pos或者迭代器位置来对字符串进行操作，其中我们只需要记住1、3、5接口常用的即可。
erase：
作用：对字符串进行删除字符操作。可以用pos下标的方式删除，也可以使用迭代器。
c_str：
作用：把当前string对象中字符串按照c格式返回。
find + npos：
find作用：在string对象的字符串中，从pos位置开始查找对应的字符、字符串、string对象是否存在，如果存在返回对应的起始位置，不存在返回npos。
npos作用：它是一个string类对象的公共静态成员常量，类型是size_t，npos=-1，表示size_t的最大值，通常用来表示不存在的位置。
substr：
作用：从字符串的pos位置开始，向后截取len个字符，并把这段字符构造成一个string对象返回。
string相关的运算符重载
operator>>：
istream& operator>>(istream& in, string& s) //流提取
{
s.clear();
char ch;
ch = in.get();
const size_t N = 31;
char buff[N];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}
operator<<：
ostream& operator<<(ostream& out, const string& s) //流插入
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
string类的模拟实现(含各类接口)
#include <iostream>
#include <assert.h>
#include <string>
using namespace std;
namespace Lh
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
// 普通迭代器/const迭代器
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
//string() //无参的构造
// :_str(new char[1])
// , _size(0)
// , _capacity(0)
//{
// _str[0] = '\0';
//}
//string(const char* str = "\0") //有参数的构造
// :_str(new char[strlen(str) + 1])
// , _size(strlen(str))
// , _capacity(strlen(str))
//{
// strcpy(_str, str);
//}
string(const char* str = "") //全缺省构造
{
_size = (strlen(str));
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
//string(const string& s) //拷贝构造--传统写法
// :_str(new char[s._capacity+1])
// ,_size(s._size)
// ,_capacity(s._capacity)
//{
// strcpy(_str, s._str);
//}
//string& operator = (const string& s) //赋值 --传统写法
//{
// if (this != &s)
// {
// delete[] _str;
// _str = new char[s._capacity + 1];
// _size = s._size;
// _capacity = s._capacity;
// strcpy(_str, s._str);
// }
// return *this;
//}
void swap(string& tmp)
{
::swap(_str, tmp._str);
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s) //拷贝构造--现代写法
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str);
swap(tmp);
}
//string& operator = (const string& s) //赋值 --现代写法
//{
// if (this != &s)
// {
// string tmp(s._str);
// swap(tmp);
// }
// return *this;
//}
string& operator = (string s) //赋值 --现代写法
{
swap(s);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const //size
{
return _size;
}
size_t capacity() const //capacity
{
return _capacity;
}
bool empty() const //判空
{
return _size == 0;
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
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) //尾插
{
//if (_size == _capacity)
//{
// reserve(_capacity == 0 ? 4 : _capacity * 2);
//}
//_str[_size] = ch;
//_size++;
//_str[_size] = '\0';
//复用insert
insert(_size, ch);
}
string& operator+=(char ch) //+=字符
{
push_back(ch);
return *this;
}
string& operator+=(const char* str) //+=字符串
{
append(str);
return *this;
}
string& insert(size_t pos,char ch) //任意位置插入字符
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;
++_size;
return *this;
}
string& insert(size_t pos, const char* str) //任意位置插入字符串
{
assert(pos <= _size);
size_t len = strlen(str);
//检查扩容
if (_size + len > _capacity)
{
reserve(_capacity + len);
}
//挪动数据
size_t end = _size + len;
while (end >= pos + len)
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
void erase(size_t pos, size_t len = npos) //某个位置删除n个字符
{
assert(pos < _size);
if (len == npos || pos + len >= _size) //如果超过_size 就删除到结尾
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
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(const char* sub, size_t pos = 0) const //查找子串
{
assert(sub);
assert(pos < _size);
char* p = strstr(_str + pos, sub);
if (p == nullptr)
{
return npos;
}
else
{
return p - _str;
}
}
string substr(size_t pos = 0, size_t len = npos) const //获取子串
{
assert(pos < _size);
size_t realLen = len;
if (len == npos || pos + len > _size)
{
realLen = _size - pos;
}
string sub;
for (size_t i = 0; i < realLen; ++i)
{
sub += _str[pos + i];
}
return sub;
}
void resize(size_t n, char ch = '\0')
{
if (n > _size)
{
//插入数据
reserve(n);
for (size_t i = _size; i < n; ++i)
{
_str[i] = ch;
}
_str[n] = '\0';
_size = n;
}
else
{
//删除数据
_str[n] = '\0';
_size = n;
}
}
bool operator!=(const string& s) const
{
return !(_str == s._str);
}
bool operator==(const string& s) const
{
return strcmp(_str, s._str) == 0;
}
bool operator>(const string& s) const
{
return strcmp(_str, s._str) > 0;
}
bool operator>=(const string& s) const
{
return _str > s._str || _str == s._str;
}
bool operator<(const string& s) const
{
return !(_str >= s._str);
}
bool operator<=(const string& s) const
{
return !(_str > s._str);
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
~string() //析构
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;
public:
// const static 变量 是C++ 的语法特例 可以不在类外面定义初始化
// 这里就是定义初始化 光static不行 必须加const
const static size_t npos = -1;
};
ostream& operator<<(ostream& out, const string& s) //流插入
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
istream& operator>>(istream& in, string& s) //流提取
{
s.clear();
char ch;
ch = in.get();
const size_t N = 31;
char buff[N];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}
}
