文章目录
- 1、string类的出现
- 1.1 C语言中的字符串
- 2、标准库中的string类
- 2.1 string类
- 3、string类的常见接口说明及模拟实现
- 3.1 string的常见构造
- 3.2 string的构造函数
- 3.3 string的拷贝构造
- 3.4 string的赋值构造
- 4、完整代码
1、string类的出现
1.1 C语言中的字符串
C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合面向对象的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。
因此C++中，为了让我们更简单、方便、快捷的使用字符串类型，C++提供了string类。
2、标准库中的string类
2.1 string类
string类文档介绍
string类在使用的时候我们需要包含头文件 #include ，以及using namespace std;
- 字符串是表示字符序列的类。
- 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
- string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
- string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
- 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
总结：
1. string是表示字符串的字符串类。
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，
typedef basic_string<char, char_traits, allocator>string;
4. 不能操作多字节或者变长字符的序列。
3、string类的常见接口说明及模拟实现
3.1 string的常见构造
| (constructor)函数名称 | 功能说明 |
|---|---|
| string() | 构造空的string类对象，即空字符串 |
| string(const char* s) | 用C-string来构造string类对象 |
| string(size_t n, char c) | string类对象中包含n个字符c |
| string(const string&s) | 拷贝构造函数 |
int main()
{
string s1; // 构造空的string类对象s1
string s2("hello"); // 用C格式字符串构造string类对象s2
string s3(s2); // 拷贝构造s3
return 0;
}
3.2 string的构造函数
namespace s
{
class string
{
public:
//string()
// :_str(new char[1]{ '\0' })//这里开一个空间，并赋值为\0，如果直接赋值为nullptr的话
// ,_size(0) //在实例化一个无参对象后，对对象进行操作的时候会引发空指针异常
// ,_capacity(0)
//{}
//全缺省构造函数
string(const char* str = "")//常量字符串默认以\0结尾，因此不需要给
: _size(strlen(str))
, _capacity(_size)
{
_str = new char[_capacity + 1];//多开一个空间，需要存放\0
strcpy(_str, str);//将字符串拷贝到_str
}
private:
char* _str;
size_t _size;//有效存储字符个数
size_t _capacity;//实际空间
};
}
这里我们用一个全缺省将无参构造与构造都包括了。
这个构造函数很简单，这里就不多讲了，大家应该可以看懂。
3.3 string的拷贝构造
传统写法：
//拷贝构造
string(const string& s)
: _size(strlen(s._str))
, _capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, s._str);
}
现代写法：
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//现代写法 s1(s2)
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);//构造
swap(tmp);//this->swap(s);
}
库里提供了交换函数，我们封装一个交换函数，内部的实现就使用库里面的swap，我们拷贝构造函数里面先调用构造函数，实例化一个tmp，再将tmp与this交换。
3.4 string的赋值构造
传统写法：
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);//拷贝构造
swap(tmp);
}
return *this;
}
现代写法：这里与拷贝构造的现代写法是类似的，不再多说。
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);//拷贝构造
swap(tmp);
}
return *this;
}
我们其实可以对现代写法继续精简一下，我们这里参数是引用传参，我们不用引用就会产生一次拷贝，对拷贝的形参直接进行交换，这样就可以简化写法，但是这里的效率其实是一样的，都是一次拷贝构造 + 一次交换。
// 极致写法，效率与上面一样
string& operator=(string tmp)//参数直接调用拷贝构造
{
swap(tmp);
return *this;
}
4、完整代码
#include <string.h>
#include <algorithm>
using namespace std;
namespace s
{
class string
{
public:
//string()
// :_str(new char[1]{ '\0' })//这里开一个空间，并赋值为\0，如果直接赋值为nullptr的话
// ,_size(0) //在实例化一个无参对象后，对对象进行操作的时候会引发空指针异常
// ,_capacity(0)
//{}
//全缺省构造函数
string(const char* str = "")//常量字符串默认以\0结尾，因此不需要给
:_size(strlen(str))
,_capacity(_size)
{
_str = new char[_capacity + 1];//多开一个空间，需要存放\0
strcpy(_str, str);//将字符串拷贝到_str
}
//拷贝构造
// 传统写法
//string(const string& s)
// :_size(s._size)
// ,_capacity(s._capacity)
//{
// _str = new char[s._capacity + 1];
// strcpy(_str, s._str);
//}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//现代写法 s1(s2)
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);//构造
swap(tmp);//this->swap(s);
}
//赋值
// 传统写法
//string& operator=(const string& s)
//{
// if (this != &s)
// {
// char* tmp = new char[s._capacity];
// strcpy(tmp, s._str);
// delete[] _str;
// _str = tmp;//将tmp字符串直接给_str，类似浅拷贝
// _size = s._size;
// _capacity = s._capacity;
// }
// return *this;
//}
//现代写法
//string& operator=(const string& s)
//{
// if (this != &s)
// {
// string tmp(s);//拷贝构造
// swap(tmp);
// }
// return *this;
//}
// 极致写法，效率与上面一样
string& operator=(string tmp)//参数直接调用拷贝构造
{
swap(tmp);
return *this;
}
~string()
{
cout << "~string()" << endl;
delete[] _str;
_size = _capacity = 0;
}
private:
char* _str;
size_t _size;//有效存储字符个数
size_t _capacity;//实际空间
};
}
