string容器
🍁简单介绍string类
什么是string类：string类其实就是以字符串类型为基础的顺序表
- string是表示字符串的字符串类
- 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
- string在底层实际是：basic_string模板类的别名，
typedef basic_string<char, char_traits, allocator> string;- 不能操作多字节或者变长字符的序列。
🍁string类中的成员变量/常量
class string
{
public:
//...
private:
char* _str; //指向所存储的字符串
size_t _size; //字符个数
size_t _capacity; //容量
static const size_t npos = -1; //const修饰的静态成员变量
};
注意：由于npos为size_t无符号整形，当值为-1时，取最大值为4294967295
C++类和对象中，静态成员变量在类中声明是不能进行赋值的，需要在类外进行初始化。
但是静态成员变量在被const修饰后就可以直接在类声明时进行赋值；如上的npos。
类和对象静态成员进行初始化情况如下：
class AA
{
private:
static int _a1; //静态成员变量不能直接进行赋值，需要在类外进行初始化
static const int _a2 = 100; //const修饰的静态成员可以在定义类时赋值
};
int AA::_a1 = 50; //指定作用域
🍁string类中常用接口及实现
由于早期设计string类的时候不合理性，成员接口高达上百个，但是常用接口往往就二十来个。
下面主要介绍string中常用的成员接口，模拟实现为SGI版本：
前提摘要：在使用string类时需要包含#include <string>头文件，并且要指定std命名空间才能使用
🍂Constructor
🍃string的构造函数
string()：将string类对象初始化为空串
string str;
string(const char* s)：利用s指针指向的字符串初始化string类对象
string str("hello world");
- 模拟实现
如上两个构造函数都可以各自实现，但是这样实现的代码复用过多。在这里主要实现成一个默认构造函数(缺省值)即可完成以上两个接口的工作
string(const char* str = "") //不给参数时，缺省参数给予空串
:_size(strlen(str))
{
_capacity = _size == 0 ? 3 : _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
初始化若为空串时，默认给三个容量的空间（当然这个由实现者自己决定）；
这里解释一下为什么开辟空间时是_capacity + 1：
多开一个空间是给'\0'，在C语言中字符串是以字符0结尾的。
🍃string的拷贝构造函数
string(const string& s)：将已经创建string对象初始化一个新的string类对象
string str1("hello world");
string str2(str1);
string str3 = str1;
模拟实现两种方法
- 方法一：常规实现
string(const string& str)
:_size(str._size), _capacity(str._capacity) //拷贝构造也是构造，利用初始化列表进行初始化
{
_str = new char[str._capacity + 1]; //多出一个空间是为了存放字符0
strcpy(_str, str._str); //进行字符串拷贝
}
注意：这里不能直接对_str成员进行直接赋值，直接赋值会造成浅拷贝问题发生
- 方法二：利用构造函数实现
string(const string& str)
:_str(nullptr),_size(0), _capacity(0)
{
string tmp(str._str); //创建临时对象
swap(tmp); //交换指针指向
}
利用
str对象的_str成员变量所指向的字符串来构造创建临时对象tmp，再改变this->_str与tmp._str字符串指针指向即可完成拷贝构造
注意：这里使用swap函数并不是不是std中的swap函数，是string类中所实现的
🍃swap
为什么string类中要再实现一个swap函数呢？
首先来简单看看std中swap函数：
对于自定义类型来说，std中swap函数用起来是非常方便的；
但是对于自定义类型来说，消耗是非常大的，需要拷贝创建一个临时对象，然后要进行赋值，赋值需要调用自定义类型的赋值重载。
所以string类实现一个属于自己的swap函数是很有必要的。
下面来看看string类中的swap函数是怎么样的：
-
void swap (string& str)： 通过str对象的内容交换this对象的内容 -
模拟实现
void swap(string& str)
{
//这里复用std中swap函数
std::swap(_str, str._str);
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
}
🍃string的析构函数
-
~string()：使用者不用手动调用，待string类对象的生命周期结束后会自动调用 -
模拟实现
~string() //析构
{
delete[] _str;
_str = nullptr;
_size = _capacity;
}
🍃string的赋值重载
string& operator=(const string& str)：将其中一个string类对象内容赋值到另一个string类对象中
string str1;
string str2("hello world");
str1 = str2;
模拟实现两种方法
- 方法一：常规实现
string& operator=(const string& str) //出了作用域生命周期没有结束可以引用返回减少消耗
{
if (this != &str) //防止自传
{
char* tmp = new char[str._capacity + 1]; //防止开辟空间失败
delete[] _str; //释放旧空间
_str = tmp;
strcpy(_str, str._str); //拷贝字符串
_size = str._size;
_capacity = str._capacity;
}
return *this;
}
如上方法细节较多，容错率低，对于实现比较推荐第二种方法
- 方法二：利用拷贝构造函数去实现
string& operator=(const string str) //传参时不传引用，进行拷贝构造
{
swap(str); //原理如上述拷贝构造一样
return *this;
}
🍂Iterators
🍃正向迭代器
iterator begin()：返回首个字符的地址，其内容可以改变iterator end()：返回最后一个字符的下一个地址，其内容可以改变
string str("hello world");
std::string::iterator it = str1.begin(); //指定std作用域
while (it != str1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
const_iterator begin()const：返回首个字符的地址，其内容不可以改变const_iterator end()const：返回最后一个字符的下一个地址，其内容不可以改变
const string str("have a good day!"); //被const修饰
std::string::const_iterator it1 = str.begin(); //指定std作用域
while (it1 != str.end())
{
cout << *it1 << " ";
++it1;
}
cout << endl;
模拟实现：
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str; //返回首个字符的地址
}
iterator end()
{
return _str + _size; //返回最后字符的下个地址
}
const_iterator begin()const //不可修改
{
return _str; //返回首个字符的地址
}
const_iterator end()const //不可修改
{
return _str + _size; //返回最后字符的下个地址
}
🍂Element access
🍃下标访问 [ ]重载
char& operator[](const size_t pos):对方括号进行重载，方便使用者进行下标访问const char& operator[](const size_t pos) const：同上，这里const修饰，只许访问不可修改
string str("hello world");
for(size_t i = 0; i < str.size(); ++i)
{
cout << str[i] << " ";
}
cout << endl;
- 模拟实现
char& operator[](const size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](const size_t pos) const //修饰this
{
assert(pos < _size);
return _str[pos];
}
🍂Capacity
🍃reserve
void reserve(size_t n)：扩容使string类对象的字符串容量大小更改为最多 n 个字符，对扩容空间不进行初始化
string str("hello world");
cout << "str.capacity():" << str.capacity() << endl;
str.reserve(100); //扩容
cout << "str.capacity():" << str.capacity() << endl;
注意： 若是n小于原来容量不进行缩容
- 模拟实现
void reserve(size_t n = 0)
{
if (n > _capacity) //若是小于容量，不采取缩容
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str; //释放原有空间
_str = tmp; //改变指针指向
_capacity = n;
}
}
这里不直接对
_str进行开辟新的空间，是为了防止开辟空间不成功造成原有数据丢失
🍃resize
-
void resize (size_t n, char c)：与reserve函数功能类似，但是resize函数扩容时可以对扩容的空间进行初始化，同样不支持缩容 -
模拟实现
void resize(size_t n, char ch = '\0')
{
if (n < _size)
{
_str[n] = ch;
_size = n; //不改变容量，改变字符串大小
}
else if (n > _size) //容量充足或是需要扩容
{
if (n > _capacity)//扩容
{
reserve(n); //复用reserve
}
//初始化方法一:
//size_t i = _size;
//while (i < n)
//{
// _str[i] = ch;
// ++i;
//}
//方法二:
memset(_str + _size, ch, n - _size);
//改变字符串大小，\0结尾
_size = n;
_str[_size] = '\0';
}
}
🍃size()
size_t size()const：获取string类对象的字符串有效字符数
string str("I love you");
cout << "str.size():" << str.size() << endl;
- 模拟实现
size_t size() const //不可修改
{
return _size;
}
🍃capacity()
size_t capacity()const：获取string对象的容量大小
string str1;
string str2("hello world");
cout << "str.capacity():" << str1.capacity() << endl;
cout << "str.capacity():" << str2.capacity() << endl;
- 模拟实现
size_t capacity()const //不可修改
{
return _capacity;
}
🍃clear()
void clear()：清空内容- 模拟实现
void clear()
{
_str[0] = '\0'; //首位字符给予字符0即可
_size = 0; //修改有效字符个数
}
🍂Modifiers
🍃push_back
void push_back(const char ch)：将字符ch追加到字符串的末尾，将其长度增加 1
string str("11111");
str.push_back('x');
cout << str.c_str() << endl;
- 模拟实现
void push_back(const char ch)
{
if (_size + 1 > _capacity) //检查容量
{
reserve(_capacity * 2); //扩容2倍是为了：防止频繁插入单个字符造成频繁扩容
}
_str[_size++] = ch;
_str[_size] = '\0'; //避免访问时无法结束
}
🍃append
string& append (const char* s)：将字符串s追加到字符串的末尾，将其长度增加 s 字符串个长度
string str("11111");
str.append("aaaaa");
cout << str.c_str() << endl;
- 模拟实现
string& append(const char* str) //尾插字符串
{
size_t len = strlen(str);
if (_size + 1 > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
return *this;
}
🍃operator+=
-
string& operator+=(char ch)：功能如同push_back() -
string& operator+=(const char* str)：功能如同append() -
模拟实现
string& operator+=(char ch)
{
push_back(ch); //复用
return *this;
}
string& operator+=(const char* str)
{
append(str); //复用
return *this;
}
🍃insert
string& insert(size_t pos, char ch)：在pos位置插入一个ch字符string& insert(size_t pos, const char* str)：在迫使位置插入str字符串
string str("hello world");
size_t pos = str.find('0');
str.insert(pos, 'x'); //插入字符x
cout << str.c_str() << endl;
pos = str.find('w');
str.insert(pos, "11111"); //插入字符串"11111"
cout << str.c_str() << endl;
- 模拟实现
string& insert(size_t pos, char ch) //pos位置插入字符ch
{
assert(pos < _size);
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
//由于size_t为无符号整形，防止end--变成-1
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) //pos位置插入字符串
{
assert(pos < _size);
size_t len = strlen(str);
if (_size + len > _capacity) //扩容
{
reserve(_size + len);
}
//挪动数据
size_t end = _size + len;
while (end >= pos + len )
{
_str[end] = _str[end - len];
--end;
}
//插入字符串
strncpy(_str + pos, str, len);
//size_t i = 0;
//while (i < len)
//{
// _str[pos + i] = str[i];
// ++i;
//}
_size += len;
return *this;
}
🍃erase
string& erase (size_t pos = 0, size_t len = npos)：删除pos位置len个字符，包括pos位置的字符
string str("11111aaaaa");
size_t pos = str.find("aaaaa");
str.erase(pos);
cout << str.c_str() << endl;
- 模拟实现
string& erase(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len + pos >= _size) //删掉pos位置以后的所有字符
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len); //挪动数据
_size -= len;
}
return *this;
}
🍂String operations
🍃c_str()
const char* c_str()：访问string对象字符串内容
string str("hello world");
str.c_str();
- 模拟实现
const char* c_str() //访问字符串,但不可以修改其内容
{
return _str;
}
🍃find
-
size_t find(char ch, size_t pos) const：字符查找，从pos位置开始查找 -
size_t find(const char* str, size_t pos) const：字符串查找，从迫使位置开始查找 -
模拟实现
size_t find(char ch, size_t pos = 0)const
{
assert(pos < _size);
size_t i = pos;
while (i < _size)
{
if (_str[i] == ch)
{
return i;
}
i++;
}
return npos;
}
size_t find(const char* str, size_t pos = 0)const
{
assert(pos < _size);
char* fstr = strstr(_str + pos, str);
if (fstr == nullptr)
{
return npos;
}
else
{
return (fstr - _str); //指针相减得到下标
}
}
🍂Compare
string类中的关系运算符，对比的是字符acsll码值，由于是运算符重载，两个对象直接比较即可
- 判断两个string对象是否相等：
bool operator==(const string& str)constbool operator!=(const string& str)const
- 判断两个string类对象的大于、大于等于、小于、小于等于：
bool operator>(const string& str)constbool operator>=(const string& str)constbool operator<(const string& str)constbool operator<=(const string& str)const
模拟实现：
bool operator==(const string& str)const
{
return strcmp(_str, str._str) == 0;
}
bool operator!=(const string& str)const
{
return !(*this == str); //复用 ==
}
bool operator>(const string& str)const
{
return strcmp(_str, str._str) > 0;
}
bool operator>=(const string& str)const
{
return *this > str || *this == str; //复用 > 和 ==
}
bool operator<(const string& str)const
{
return !(*this >= str); //复用 >=
}
bool operator<=(const string& str)const
{
return !(*this > str); //复用 >
}
🍂Non-member function overloads
🍃operator<<
ostream& operator<< (ostream& out, const string& str)：流插入string类对象，将符合 str 值的字符序列插入到 out 中
string str("hello world");
cout << str << endl;
- 模拟实现
ostream& operator<<(ostream& out, const string& str)
{
auto it = str.begin();
while (it != str.end())
{
out << *it;
++it;
}
return out;
}
🍃operator>>
istream& operator>>(istream& in, string& str)：从输入流中提取字符串，将序列存储在 str 中，该序列被覆盖（替换 str 的先前值）
string str("hello world");
cout << str << endl;
cin >> str;
cout << str << endl;
- 模拟实现
istream& operator>>(istream& in, string& str)
{
str.clear();
//不直接用(in >> ch)原因是：in会将 ' ' 和 '\n'识别成分割符，不起作用
//in.get()会将输入字符的值进行识别，in.get()返回值为char
char ch = in.get();
char buff[128];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
//为了防止频繁扩容，利用buff数组进行预存储
buff[i++] = ch;
if (i == 127)
{
buff[i] = '\0';
str += buff; //buff满了直接尾插字符串
i = 0;
}
ch = in.get();
}
//将buff中剩余的其他字符写入str中
if (i != 0)
{
buff[i] = '\0';
str += buff;
}
return in;
}
🍁代码展示
为了区别于标准库中的#include <string>，这里创建了新的命名空间namespace MySpace
#include <iostream>
#include <string.h>
#include <assert.h>
using std::cout;
using std::endl;
namespace MySpace
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin()const
{
return _str;
}
const_iterator end()const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
{
_capacity = _size == 0 ? 3 : _size;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
string(const string& str)
:_size(str._size), _capacity(str._capacity)
{
_str = new char[str._capacity + 1];
strcpy(_str, str._str);
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity;
}
string& operator=(const string& str)
{
if (this != &str)
{
char* tmp = new char[str._capacity + 1];
delete[] _str;
_str = tmp;
strcpy(_str, str._str);
_size = str._size;
_capacity = str._capacity;
}
return *this;
}
bool operator==(const string& str)const
{
return strcmp(_str, str._str) == 0;
}
bool operator!=(const string& str)const
{
return !(*this == str);
}
bool operator>(const string& str)const
{
return strcmp(_str, str._str) > 0;
}
bool operator>=(const string& str)const
{
return *this > str || *this == str;
}
bool operator<(const string& str)const
{
return !(*this >= str);
}
bool operator<=(const string& str)const
{
return !(*this > str);
}
char& operator[](const size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](const size_t pos)const
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n = 0)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n, char ch = '\0')
{
if (n < _size)
{
_str[n] = ch;
_size = n;
}
else if (n > _size)
{
if (n > _capacity)
{
reserve(n);
}
memset(_str + _size, ch, n - _size);
_size = n;
_str[_size] = '\0';
}
}
void push_back(const char ch)
{
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
_str[_size++] = ch;
_str[_size] = '\0';
}
string& append(const char* str)
{
size_t len = strlen(str);
if (_size + 1 > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
return *this;
}
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 + 1 > _capacity)
{
reserve(_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(_size + 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;
}
string& erase(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len + pos >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}
size_t find(char ch, size_t pos = 0)const
{
assert(pos < _size);
size_t i = pos;
while (i < _size)
{
if (_str[i] == ch)
{
return i;
}
i++;
}
return npos;
}
size_t find(const char* str, size_t pos = 0)const
{
assert(pos < _size);
char* fstr = strstr(_str + pos, str);
if (fstr == nullptr)
{
return npos;
}
else
{
return (fstr - _str);
}
}
void swap(string& str)
{
std::swap(_str, str._str);
std::swap(_size, str._size);
std::swap(_capacity, str._capacity);
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
const char* c_str() //访问字符串
{
return _str;
}
size_t size()const //字符串有效字符数
{
return _size;
}
size_t capacity()const //容量
{
return _capacity;
}
private:
char* _str;
size_t _size;
size_t _capacity;
//npos也可以这样写：
//static const size_t npos = -1;
static const size_t npos;
};
const size_t string::npos = -1;
ostream& operator<<(ostream& out, const string& str)
{
auto it = str.begin();
while (it != str.end())
{
out << *it;
++it;
}
return out;
}
istream& operator>>(istream& in, string& str)
{
str.clear();
char ch = in.get();
char buff[128];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[i] = '\0';
str += buff;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
str += buff;
}
return in;
}
string容器就介绍到这里，感谢大家支持！！！
1221
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
