前言:在C语言中,我们经常使用字符串进行一系列操作,经常使用的函数如下:增删改查
(自己造轮子),C++中设计出string容器,STL库中为我们提供了以上函数,所以我们使用string容器时,就不用造轮子了
参考网站:https://legacy.cplusplus.com/reference/string/string/?kw=string
底层实现,这里我用的是VS的编译器(window)(简化版本),linux(g++)这里使用计数引用(这里不采用计数引用实现)
constructor(构造函数)
第一个(第四个):是无参构造
#include<string>
#include<iostream>
using namespace std;
int main()
{
string s;
return 0;
}
s中只含有'\0'(无参构造时)
底层实现:(运用全缺省构造)
string(const char* arr = "")
{
int len = strlen(arr);
_str = new char[len + 1];// '\0'要单独开空间
strcpy(_str, arr);
_size = len;
_capacity = len;
}
第二个:拷贝构造(将 str 中的所有成员变量全部赋值给*this)
string(const string& s)
{
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}
第三个:将str中的字符串从下标为pos ,拷贝字符的个数为npos
(注意npos 为默然时,则为字符串能存储最多的个数,不是_capacity,而是系统默然能储存的最大值,此时npos = -1)
当npos > len - pos 时 , 就拷贝全部
举个例子:
destructor(析构函数)
~string()
{
delete[] _str;
_size = 0;
_capacity = 0;
}
operator=(赋值重载)
string& operator=(const string& s)
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
_size = s._size;
_capacity = s._capacity;
delete[] _str;
_str = tmp;
return *this;
}
//现代写法
string& operator=(string s)
{
swap(s);
return *this;
}
现代写法含义:传参时,s进行拷贝构造,在交换*this与s
iterator(迭代器)
迭代器的行为像指针
范围for的原理就是迭代器
#include<string>
#include<iostream>
using namespace std;
int main()
{
string s("0000000000000000000");
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
return 0;
}
#include<string>
#include<iostream>
using namespace std;
int main()
{
string s("0000000000000000000");
for( auto e : s )
cout << e << " ";
cout << endl;
return 0;
}
这两个代码等效,原理都是迭代器
//迭代器底层实现
char* begin()
{
return _str;
}
char* end()
{
return _str + _size;
}
char* rbegin()
{
return _str + _size;
}
char* rend()
{
return _str;
}
capacity(容量)
_capacity当前开辟的空间最多能储存多少字符
_size代表当前有多少个有效的字符
库里面有提供查询_capacity,_size的函数
int size()
{
return _size;
}
int capacity()
{
return _capacity;
}
如何扩容:(库里面有两个函数,可以实现扩容)
第一个reserve
传入一个size_t的参数,作为要扩容到标准
当 n <= _capacity 一般不会造成缩容(这个要具体看编译器)
当 n > _capacity 会扩容
void reserve(size_t n = 0)
{
if (n <= _capacity)return;
else
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
第二个resize函数
当 n < _size 会造成有效数据的删除(有可能会缩容)
当 n > _size 且n < _capacity 有可能会缩容,但会造成添加有效数据,一直到 n
当 n > _capacity 会造成扩容,并添加有效数据的个数,一直到 n
void resize(size_t n, char c = '\0')
{
if (n <= _size)
{
_size = (int)n;
_str[n] = '\0';
}
else
{
reserve(n);
for (; _size < n; _size++)
{
_str[_size] = c;
}
_str[_size] = '\0';// n为最多有效字符个数,_str[n] = '\0';
}
}
clear函数
清空有效数据,令_size = 0;
empty函数
判断有效数据个数是否为0
operator[]
放回下标为pos的字符
char& operator[] (size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[] (size_t pos) const
{
assert(pos < _size);
return (const char )_str[pos];
}
需要assert(判断pos < _size ),防止对未进行赋值的位置解引用
operator+=(传入的是字符串也可以,因为会进行隐式类型转换)
string& operator+=(const string& s)
{
if (s._size + _size > _capacity )
{
reserve(s._size + _size);
}
strcpy(_str + _size, s._str);
_size += s._size;
return *this;
}
在字符串末尾添加字符串
具体使用:与整形变量的使用方法一样
append(传入的是字符串也可以,因为会进行隐式类型转换)
string& append(const string& str)
{
*this += str;//复用上面的+=
return *this;
}
举个例子:
push_back
在字符串末尾添加一个字符
void push_back(char ch)
{
if (_size == _capacity)
{
reserve(_size * 2);
}
_str[_size++] = ch;
_str[_size] = '\0';
}
assign(容量不改变)
第一个,第三个相当与拷贝构造
第二个就是将str中的字符串中的下标从subpos位置的sublen个字符,拷贝给*this
string& assign(const string& str, size_t subpos, size_t sublen)
{
assert(_size - subpos >= sublen && sublen >= 0 );
if (sublen > _capacity)reserve(sublen + _capacity);
memcpy(_str, str._str + subpos, sublen);
_size = sublen;
_str[_size] = '\0';
return *this;
}
第四个将s中的字符串前n个字符,给*this;
string& assign(const char* s, size_t n)
{
if (n > _capacity)reserve(n);
memcpy(_str, s, n);
_size = n;
_str[_size] = '\0';
return *this;
}
第五个将n个字符c给*this
string& assign(size_t n, char c)
{
if (n > _capacity)reserve(n);
for (int i = 0; i < n; i++)
{
_str[i] = c;
}
_size = n;
_str[n] = '\0';
return *this;
}
insert
请注意可以插入一个string
在pos位置前插入字符或字符串
string& insert(size_t pos, char c)
{
if( _capacity == _size )reserve( 2 * _size );
for (size_t i = _size; i > pos; i--)
{
_str[i] = _str[i - 1];
}
_size++;
_str[pos] = c;
}
string& insert(size_t pos, const char* str)
{
int len = strlen(str);
if (len + _size > _capacity)reserve(len + _size);
for (size_t i = _size + len ; i >= pos + len; i--)
{
_str[i] = _str[i - len];
}
_size += len;
memcpy(_str + pos, str, sizeof(char) * len);
return *this;
}
使用方法:
自定义类型的变量 . insert ( 参数列表 )
erase
string& erase(size_t pos = 0, size_t len = npos)
{
assert(pos >= 0);
if (pos + len >= _size)_size = pos;
else
{
for (size_t i = pos + len; i < _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
_str[_size] = '\0';
return *this;
}
从下标为pos的位置,删除len个字符,其中当len == npos时,就将从pos位置起以后(包括pos位置的数据)的数据删除
find
size_t find(char c, size_t pos = 0) const
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)return i;
}
return -1;//npos
}
size_t find(const char* s, size_t pos = 0) const
{
char* tmp = strstr(_str , s );
if (tmp == nullptr)
return -1;
else return tmp - _str;
}
找寻_str中是否存在字符c或字符串s,如果存在返回第一次出现时的下标
不存在,返回-1