目录
一、string类
1、 string是表示字符串的字符串类。2、 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。3、 string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>string。4、 不能操作多字节或者变长字符的序列。在使用string类时，必须包含#include<string>头文件以及using namespace std。
那么接下来我们就来模仿标准库里的string类来进行一个模拟实现，进而更深层次地理解string容器。 (为了与标准库区分，我们在自己的命名空间里来实现)
首先根据源码，我们可以知道string中的主义成员变量我们可以写成 char* _str（字符数组），size_t _size（数据个数），size_t _capacity（容量大小）。
二、构造函数、拷贝构造函数及析构函数
1、构造函数
string的构造函数分为无参构造和有参构造，通过无参构造的对象会被默认生成一个空字符串，因此我们可以带一个缺省值。没有参数时就直接构造一空串。
string(const char* str = "")
:_str(new char[strlen(str) + 1])
, _size(strlen(str))
, _capacity(strlen(str))
{
strcpy(_str, str);
}注：在开空间时，我们需要多开一个空间，因为strlen算出的大小不包含 ‘\0’ ，因此我们需要给 ‘\0’留一个空间。
2、拷贝构造函数
拷贝构造函数是默认成员函数，如果不写编译器会自动生成，对于内置类型完成浅拷贝，对于自定义类型调用其拷贝构造函数完成拷贝。对于string类型来说，如果不自己写拷贝构造函数会导致浅拷贝问题。
如果仅仅依靠编译器自己提供的拷贝构造函数，就会像上图一样两个对象指向同一块空间。这就是我们所说的浅拷贝，浅拷贝有两大缺点：1、两个对象在析构时都会调用自己的析构函数，这样同一块空间就会被析构两次；2、一个对象的数据改变，另一个对象的数据也改变了。
因此我们自己实现一个拷贝构造函数尤为重要。我们需要进行深拷贝。
string(const string& str)
:_str(new char[str._capacity+1])
,_size(str._size)
,_capacity(str._capacity)
{
strcpy(_str, str._str);
}上面的这种实现方法是比较常见的一种写法，但是我们还有一种更加简便的写法。我们可以通过已经实现了的构造函数传一个常量字符串，即下面的 str . _str，来创建一个l临时对象，然后将这个临时对象的成员与自己交换，这样也完成了拷贝构造。
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
string(const string& str)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(str._str);
swap(tmp);
}但是，为了写成这个拷贝构造函数我们还写了一个swap函数，这这么就简便了呢？
那是因为通过查阅标准库我们发现swap函数也是一个string类中提供了的函数，因此我们不仅简便了拷贝构造函数的写法，还又完成了一个函数的实现。并且，因为tmp是一个局部对象，因此在出作用域后就会自动调用析构函数，所以交换后还可以清理掉原来的空间，一举两得。
注：蓝色的swap函数是我们自己写的，而黄色的，前面写明了域的swap函数是C++库中的一个现成的函数。这两个一定要区别开来。
3、析构函数
我们可以使用delete直接释放掉 _str的空间。
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}三、string类中对容量操作的成员函数
1、size
它的功能是返回字符串有效字符的长度。我们可以直接返回其成员变量中的 _size。
size_t size()const
{
return _size;
}2、capacity
它的功能是返回返回空间总大小 。我们可以直接返回其成员变量中的 _capacity
size_t capacity()const
{
return _capacity;
}3、reserve
它的功能是为字符串预留空间
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}4、resize
它的功能是将有效字符的个数改成n个，多出的空间用字符 ch 填充。
_size < n <_capacity 先预留 n 大小的空间。直接用字符 ch 填充 n - _size 位置，记住要在最后加上 ‘\0’
_size > n 直接将 n 位置的置成 ’\0‘
n > _capacity
先预留 n 大小的空间，剩下的空间用字符 ch 填充，记住要在最后加上 ‘\0’。
void resize(size_t n, char ch = '\0')
{
if (n > _size)
{
reserve(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
else
{
//删除数据
_str[n] = '\0';
_size = n;
}
}5、clear
它的作用是清空有效字符
void clear()
{
_str[0] = '\0';
_size = 0;
}6、empty
它的作用是检测字符串释放为空串，是返回true，否则返回false
bool empty()const
{
return _size == 0;
}四、string类中对象的增删查改操作
1、push_back
在字符串后尾插字符c
void push_back(char ch)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}2、append
在字符串后追加一个字符串
void append(const char* str)
{
size_t len = strlen(str);
if (_capacity < len + _size)
{
reserve(len + _size);
}
strcpy(_str + _size, str);
_size += len;
}3、c_str
返回C格式字符串
const char* c_str()const
{
return _str;
}补充：C语言字符串和 string类字符串的区别(下面我们来通过一段代码来看看他们的区别)
void test_string8()
{
string s1("hello");
s1 += '\0';
s1 += "De Bruyne";
cout << s1 << endl;
cout << s1.c_str() << endl;
}代码运行结果如下：
通过上面的运行结果我们可以看出C语言的字符串一定是通过 ’\0‘ 结束的；而string 的字符串中 ’\0‘ 不一定就是字符串结束的标志。
4、find
npos是string类的静态成员变量，静态成员变量要在类外定义的。我们一般将它设为公共权限，并赋值为 -1。
在字符串中寻找一个字符
size_t find(char ch, size_t pos = 0)const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (ch == _str[i])
{
return i;
}
}
return npos;
}在字符串中寻找字符串
size_t find(const char* sub, size_t pos = 0)const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, sub);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}5、substr
它的作用是在str中从pos位置开始，截取n个字符，然后将其返回
string substr(size_t pos, size_t len = npos)const//取子串
{
assert(pos < _size);
size_t reallen = len;
if (reallen == npos || reallen + pos > _size)
{
reallen = _size - pos;
}
string sub;
for (size_t i = pos; i < reallen + pos; i++)
{
sub += _str[i];
}
return sub;
}6、insert
插入一个字符
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(_size + len);
}
size_t end = _size + len;
while (pos + len <= end)
{
_str[end] = _str[end - len];
end--;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}7、erase
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}五、string对于重要的运算符重载
1、赋值运算符的重载
编译器默认生成的赋值重载也会导致浅拷贝，所以我们需要实现深拷贝。
string& operator=(const string& str)
{
if (this != &str)
{
char* tmp = new char[str._capacity + 1];
strcpy(tmp, str._str);
delete[] _str;
_str = tmp;
_size = str._size;
_capacity = str._capacity;
}
return *this;
}和拷贝构造函数一样，我们也可以用简便写法来实现赋值运算符的重载。（注意不要自己给自己赋值）。
string& operator=(const string& str)
{
if (this != &str)
{
string tmp(str);
swap(tmp);
}
return *this;
} 2、流插入 <<
类外定义
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}
return out;
}3、流提取 >>
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
ch = in.get();
const size_t N = 32;
char buff[N];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;/*先将输入的字符存在buff数组中，然后一次性+=到s中，这样就避免了输入的
字符串过大，使s频繁扩容的现象。*/
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}4、下标访问 [ ]
普通对象：可读可写
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const对象：可读不可写
char operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}5、加等一个字符 +=
我们可以直接复用push_back来实现一个字符的加等
string& operator+=(char ch)
{
push_back(ch);
return *this;
}6、加等字符串 +=
我们可以直接复用append来实现字符串的加等
string& operator+=(const char* str)
{
append(str);
return *this;
}7、大于 >
bool operator>(const string& s)const
{
return strcmp(_str, s._str) > 0;
}8、等于 ==
bool operator==(const string& s)const
{
return strcmp(_str, s._str) == 0;
}9、小于 <
bool operator<(const string& s)const
{
return !(_str > s._str) && !(_str == s._str);
}
10、大于等于 >=
bool operator>=(const string& s)const
{
return !(_str < s._str);
}
11、小于等于 <=
bool operator<=(const string& s)const
{
return !(_str > s._str);
}
12、不等于 !=
bool operator!=(const string& s)const
{
return !(_str == s._str);
}
六、迭代器与范围for
1、迭代器
迭代器作为STL的六大组件之一，它的作用十分重要。而在string中迭代器的本质就是一个 char* 或 const char* 的指针。
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;
}2、范围for
范围for是C++11支持的更简洁的新遍历方式。但是其实它没有什么高大上的，它的本质还是去调用迭代器来实现遍历的。因此我们只要实现了迭代器后，就可以直接使用范围for，根本不用自己去实现。
我们从下面的汇编代码的红色标记处可以看出范围for和迭代器的底层实现都是去call的begin()和end()，因此范围for的底层就是迭代器。
3、结果对比
void test_string9()
{
string s("hello world");
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
}
七、完整代码
string.h
#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include<iostream>
using namespace std;
#include<cstring>
#include<cassert>
namespace zdl
{
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;
}
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
//构造函数
string(const char* str = "")
:_str(new char[strlen(str) + 1])
, _size(strlen(str))
, _capacity(strlen(str))
{
strcpy(_str, str);
}
/*string()
:_str(new char[1])
, _size(0)
, _capacity(0)
{
_str[0] = '\0';
}*/
//拷贝构造函数:要深拷贝
string(const string& str)
:_str(new char[str._capacity+1])
,_size(str._size)
,_capacity(str._capacity)
{
strcpy(_str, str._str);
}
/*简便写法 string(const string& str)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(str._str);
swap(tmp);
}*/
//赋值
string& operator=(const string& str)
{
if (this != &str)
{
char* tmp = new char[str._capacity + 1];
strcpy(tmp, str._str);
delete[] _str;
_str = tmp;
_size = str._size;
_capacity = str._capacity;
}
return *this;
}
/*简便写法 string& operator=(const string& str)
{
if (this != &str)
{
string tmp(str);
swap(tmp);
}
return *this;
} */
//析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
const char* c_str()const
{
return _str;
}
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
char& operator[](size_t pos) const
{
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';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_capacity < len + _size)
{
reserve(len + _size);
}
strcpy(_str + _size, str);
_size += len;
}
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(_size + len);
}
size_t end = _size + len;
while (pos + len <= end)
{
_str[end] = _str[end - len];
end--;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
size_t find(char ch, size_t pos = 0)const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (ch == _str[i])
{
return i;
}
}
return npos;
}
size_t find(const char* sub, size_t pos = 0)const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, sub);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
string substr(size_t pos, size_t len = npos)const//取子串
{
assert(pos < _size);
size_t reallen = len;
if (reallen == npos || reallen + pos > _size)
{
reallen = _size - pos;
}
string sub;
for (size_t i = pos; i < reallen + pos; i++)
{
sub += _str[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;
}
_size = n;
_str[_size] = '\0';
}
else
{
//删除数据
_str[n] = '\0';
_size = n;
}
}
bool operator>(const string& s)const
{
return strcmp(_str, s._str) > 0;
}
bool operator==(const string& s)const
{
return strcmp(_str, s._str) == 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;
public:
static size_t npos;
};
size_t string::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 = 32;
char buff[N];
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;/*先将输入的字符存在buff数组中，然后一次性+=到s中，这样就避免了输入的字符串过大，使s频繁扩容的现象。*/
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}
void test_string1()
{
string s1("hello world");
string s2(s1);
string s3;
cout << "s1: " << s1 << endl;
cout << "s2: " << s2 << endl;
cin >> s3;
cout << "s3: " << s3 << endl;
string s4("ZD");
s4 += 'L';
cout << "s4: " << s4 << endl;
s4 += " ";
s4 += "and";
s4 += " ";
s4 += "De Bruyne";
cout << "s4: " << s4 << endl;
}
void test_string2()
{
string s5("hello");
s5.append("ZDL 17");
cout << "s5: " << s5 << endl;
}
void test_string3()
{
string s6("hello");
s6.insert(0, '#');
cout << "s6: " << s6 << endl;
}
void test_string4()
{
string s7("hello");
s7.insert(2, "ZDL");
cout << "s7: " << s7 << endl;
}
void test_string5()
{
string s8("helloeeeeeelllooo");
s8.erase(2, 2);
cout << "s8: " << s8 << endl;
}
void test_string6()
{
string s9("hello world ZDL waiting for love");
string s10 = s9.substr(6, 5);
cout << "s10: " << s10 << endl;
}
void test_string7()
{
string s11("hello world ZDL waiting for love");
string s12("shfshf");
cout << "比较: " << (s11 > s12) << endl;
string s13("De Bruyne");
string s14("De Bruyne");
cout << "s13 与 s14: " << (s13 == s14) << endl;
}
void test_string8()
{
string s1("hello");
s1 += '\0';
s1 += "De Bruyne";
cout << s1 << endl;
cout << s1.c_str() << endl;
}
void test_string9()
{
string s("hello world");
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
}
}test.cpp
#include"string.h"
int main()
{
zdl::test_string1();
cout << "------------------------------" << endl;
zdl::test_string2();
cout << "------------------------------" << endl;
zdl::test_string3();
cout << "------------------------------" << endl;
zdl::test_string4();
cout << "------------------------------" << endl;
zdl::test_string5();
cout << "------------------------------" << endl;
zdl::test_string6();
cout << "------------------------------" << endl;
zdl::test_string7();
cout << "------------------------------" << endl;
zdl::test_string8();
cout << "------------------------------" << endl;
zdl::test_string9();
return 0;
}
1869
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
