目录
简介：C++string 是C++中的字符串。 字符串对象是一种特殊类型的容器，专门设计来操作的字符序列。 不像传统的c-strings,只是在数组中的一个字符序列，我们称之为字符数组，而C + +字符串对象属于一个类，这个类有很多内置的特点，在操作方式，更直观，另外还有很多有用的成员函数。 string 的定义为：typedef basic_string string。
String的常用接口说明(最常用的)
| (constructor)函数名称 | 功能说明 |
|---|---|
| string() (重点) | 构造空的string类对象，即空字符串 |
| string(const char* s)(重点) | 用C-string(字符串)来构造string对象 |
| string(size_t n,char c) | string类对象中包含n个字符c |
| string(const string&s)(重点) | 拷贝构造函数 |
| ~string() | 析构函数 |
下面是对常用接口的模拟：
构造函数
namespace my_string
{
class string
{
public:
string(const char* str = "") //构造函数
{ //构造函数可以是缺省的
_size = strlen(str); //当没有传初始化值的时候默认初始化成空串
_capacity = _size;
_str = new char[_capacity + 1];
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}拷贝构造函数
namespace my_string
{
class string
{
public:
string(const string& s) //拷贝构造函数
:_str(new char[s._capacity + 1]) //是用一个string类去初始化宁一个string类
, _size(s._size)
, _capacity(s._capacity)
{
strcpy(_str, s._str); //s._str复制到_str
}
void swap(string &tmp)
{
::swap(_str, tmp._str);//这里使用::是使用c++库中的swap函数
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s)//要把string类s 给 _str 所以要清除_str
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}这里第一个是普通写法，第二个是打工人写法，首先要知道我们模拟的string类中有一个保存字符串的私有成员：_str 这时候要给_str赋值可以先建立一个打工人tmp 用 传过来的string类s来调用构造函数来构造tmp，再交换tmp和_str的各项的数值。
注意 ：如果String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会生成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}string类对象的容量操作
| 函数名称 | 功能说明 |
|---|---|
| size(重点) | 返回字符串有效长度 |
| length | 返回字符串有效长度 |
| capacity | 返回总空间大小 |
| empty(重点) | 检测字符串是否为空串，是返回true否则返回flase |
| clear(重点) | 清除有效字符 |
| reserve(重点) | 为字符串预留空间 |
| resize(重点) | 将有效字符个数改成n个，多出的空间用字符c填充 |
namespace my_string
{
class string
{
size_t size()const //由于length跟size一个性质 就实现size
{
return _size;
}
size_t capacity()const //返回my_string类中私有成员_capacity
{
return _capacity;
}
bool empty()const
{
return _size == 0; //如果_size为0代表有效字符为0 字符串为空
}
void clear()
{
_str[0] = '\0'; //清除my_string中的有效字符，但容量不变
_size = 0;
}
void reserve(size_t n) //给函数扩容n个
{
if (_capacity < n) //如果输入的n小于_capacity就不扩容
{
char* tmp = new char[n + 1];//有效字符为n开n+1是为了给'\0'留个位置
_size = n;
_capacity = n;
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
}
}
void resize(size_t n, char c = '\0')//调整容器的有效数量 hello
{
if (n <= _capacity)//截取 小于等于 容量
{
_str[n] = '\0';
}
else {
reserve(n); //扩容
_capacity = n;
for (int i = _size; i < n; i++)//填充
{
push_back(c);//尾插
}
}
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}注意：
1 ) size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
2 ) clear()只是将string中有效字符清空，不改变底层空间大小
3 ) reserve(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变
4 ) 当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小
string类对象的访问及遍历操作
| 函数名称 | 功能说明 |
|---|---|
| operator[ ](重点 ) | 返回pos的位置的字符，const string类对象调用 |
| begin+end | begin获取第一个字符迭代器+end获取最后一个字符下一个位置的迭代器 对于正向迭代器，-- 运算将访问前一个元素， |
| rbegin+rend | rbegin获取最后一个字符迭代器+end获取第一个字符前一个位置的迭代器， 对于反向迭代器， |
| 范围for | C++11支持更简洁的范围for新遍历方式 |
namespace my_string
{
class string
{
public:
char& operator[](size_t index) //重载[]
{
assert(index < _size);
return _str[index];
}
const char& operator[](size_t index)const
{
assert(index < _size);
return _str[index];
}
typedef char* iterator; //iterator就是char* 类型的指针
typedef const char* const_iterator; //const_iterator就是 const char* 类型的指针
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}string类对象的修改操作
| 函数名称 | 功能说明 |
|---|---|
| push_back | 在字符串后尾插字符c |
| append | 在字符串后追加一个字符串 |
| operator+=（重点） | 在字符串后追加字符串str |
| c_str（重点） | 返回C格式字符串 |
| find+npos（重点） | 从字符串pos位置开始找字符c，返回该字符的位置 |
| rind | 从字符串pos位置开始找字符c，返回该字符的位置 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
namespace my_string
{
class string
{
public:
void push_back(char c)
{
if (_size == _capacity) //日常检测空间满了没有
{
reserve(_capacity == 0 ? 4 : 2 * _capacity);//调用reserve开空间
}
_str[_size] = c;
_size++;
_str[_size] = '\0';
}
void append(const char* str) //追加字符串
{
int len = strlen(str);
if (len + _size > _capacity)//老规矩检查容量
{
reserve(len + _size);
}
strcpy(_str+_size, str);
_size += len;
}
string& operator+=(const char* str)
{
append(str); //直接复用
return *this; //返回是为了可以连续+= a+=b+=c
}
const char* c_str()const
{
return _str; //返回字符串(返回的是char*)
}
size_t find(char c, size_t pos = 0) const //返回的是第一次找到字符c的位置
{
for (int i = 0; i < _size; i++)
{
if (_str[i] == 'c')
return i;
}
return npos; //没找到返回npos值为-1
}
size_t find(const char* s, size_t pos = 0) const //返回字符串第一次出现的位置
{
const char* ptr = strstr(_str + pos, s); //c库中找子串的函数
if (ptr == nullptr)
{
return npos;
}
else {
return ptr - _str; //指针相减得出位置
}
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}string类非成员函数
| 函数 | 功能说明 |
|---|---|
| operator+ | 尽量少用，传值返回，导致深拷贝效率低 |
| operator>>（重点） | 输入运算符重载 |
| operator<<（重点） | 输出运算符重载 |
| relation operators（重点） | 大小比较 |
namespace my_string
{
class string
{
public:
string& operator+(const char* str)
{
string tmp(*this);
tmp += str;
return tmp;
}
friend ostream& operator<<(ostream& _cout, const my_string::string& s);
friend istream& operator>>(istream& _cin, gch::string& s);
bool operator<(const string& s)
{
return strcmp(_str, s._str) < 0;
}
bool operator<=(const string& s)
{
return !(_str > s._str);
}
bool operator>(const string& s)
{
return strcmp(_str, s._str) > 0;
}
bool operator>=(const string& s)
{
return !(_str < s._str);
}
bool operator==(const string& s)
{
return strcmp(_str, s._str) == 0;
}
bool operator!=(const string& s)
{
return !(_str == s._str);
}
private:
char* _str;//字符串
size_t _capacity;//容量
size_t _size;//大小
public:
const static int npos = -1;
};
}
ostream& operator<<(ostream& _cout, const my_string::string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
_cout << s[i]; //_cout就是输出流里cout的别名 下面cin同理
}
return _cout;
}
istream& operator>>(istream& _cin, my_string::string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
_cin >> s[i];
}
return _cin;
}深浅拷贝
浅拷贝 ：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规
图中为浅拷贝，s1和s2指向同一块空间
深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供
图中为深拷贝s1与s2分别指向不同的的空间。
95
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
