【C++】——string(模拟实现)

这篇博客中构造、拷贝构造、析构、还有一些短小频繁调用的函数就不用做函数和定义分离，因为在类中，这种函数会默认是内联函数

string类构造

构造函数有一些容易忽略的细节，我会在下面的代码注释中说明

		#include<iostream>
#include<assert.h>
#include<string.h>
using namespace std;
namespace sg
{class string{public:string()//:_str(nullptr) // 不能这么写，因为当我string对象为空，程序解引用到\0才会终止，遇不到就会崩溃:_str(new char[1]{'\0'}) // 空间里至少要有一个字符, _size(0), _capacity(0){}//构造函数string(const char* str){_size = strlen(str);_capacity = strlen(str);_str = new char[strlen(str) + 1];strcpy(_str, str);}private:char* _str;size_t _size;size_t _capacity;};void test_string1();}

还有另一种写法，不用初始化，直接在构造函数的参数给上缺省值

/*string():_str(new char[1]{'\0'}), _size(0), _capacity(0)
{}*/
//构造函数
//string(string(const char* str = nullptr)
// 如果参数又给空，程序还是会崩，C语言规定常量字符串后面都会有\0,所以直接给空字符串就行
string(const char* str = "")
{_size = strlen(str);_capacity = strlen(str);_str = new char[strlen(str) + 1];strcpy(_str, str);
}

string类拷贝构造

如果使用默认拷贝构造，会引发浅拷贝问题，就是当两个对象指向同一块资源时，释放资源后，会导致一块资源被析构两次，程序会报错。所以自己写一个深拷贝最好

//拷贝构造函数
//s2(s1)
string(const string& s)// this就是s2
{_str = new char[s._capacity + 1]; // 开一个和s1一样大的空间strcpy(_str, s._str); _size = s._size;_capacity = s._capacity;
}

string类析构

string的析构和c语言栈实现中的销毁栈大差不差，如果有疑问可以参考这一篇博客
C语言栈和队列

//析构函数
~string()
{if (_str)     //检查一下_str是否为空，如果为空就不用再释放空间了{delete[] _str;_str = nullptr;_size = _capacity = 0;}    }

string类运算符重载

string.h

char& operator[](size_t pos)
{assert(pos < _size);return _str[pos];
}
const char& operator[](size_t pos) const
{assert(pos < _size);return _str[pos];
}

string.cpp

#define   _CRT_SECURE_NO_WARNINGS 1
#include "practice-string.h"
namespace sg
{void test_string1(){string s1;string s2("hello world");cout << s1.c_str() << endl;cout << s2.c_str() << endl;for (size_t i = 0; i < s2.size(); i++){s2[i] += 2;}for (auto e : s2){cout << e << " ";}cout << endl;cout << s2.c_str() << endl;}
}

我通过测试，发现并不能用范围for遍历，报错显示未找到匹配的begin函数，需要我们自己实现
范围for看着很方便，但本质就是迭代器，迭代器模拟的是指针的行为，所以我们返回原生指针即可

string.h

typedef char* iterator;
typedef 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 operator=(const string& s)
{if (this != &s)//地址相同，就是自己赋值给自己{delete[] _str;_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}return *this;
}

string类部分常用接口的模拟实现

string.h

#pragma once
#include<iostream>
#include<assert.h>
#include<string.h>
using namespace std;
namespace sg
{class string{public:typedef char* iterator;typedef 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():_str(new char[1]{'\0'}), _size(0), _capacity(0){}*///构造函数string(const char* str = ""){_size = strlen(str);_capacity = strlen(str);_str = new char[strlen(str) + 1];strcpy(_str, str);}//析构函数~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}//拷贝构造函数//s2(s1)string(const string& s){_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}const char* c_str() const{return _str;}size_t size() const{return _size;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}const char& operator[](size_t pos) const{assert(pos < _size);return _str[pos];}// s2 = s1// s1 = s1string operator=(const string& s){if (this != &s)//地址相同，就是自己赋值给自己{delete[] _str;_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}return *this;}void clear(){_str[0] = '\0';_size = 0;}void reserve(size_t n);void push_back(char ch);void append(const char* str);string& operator+=(char ch);string& operator+=(const char* str);void insert(size_t pos, char ch);void insert(size_t pos, const char* str);void erase(size_t pos, size_t len = npos);size_t find(char ch, size_t pos = 0);size_t find(const char* str, size_t pos = 0);string substr(size_t pos = 0, size_t len = npos);private:char* _str;size_t _size;size_t _capacity;static const size_t npos;};void test_string1();void test_string2();bool operator<(const string& s1, const string& s2);bool operator<=(const string& s1, const string& s2);bool operator>(const string& s1, const string& s2);bool operator>=(const string& s1, const string& s2);bool operator!=(const string& s1, const string& s2);bool operator==(const string& s1, const string& s2);ostream& operator<<(ostream& out, const string& s);istream& operator>>(istream& in, string& s);
}

string.cpp

#define   _CRT_SECURE_NO_WARNINGS 1
#include"string.h"
namespace sg
{const size_t string::npos = -1;//声明和定义分离void string::reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void string::push_back(char ch){if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;++_size;_str[_size] = '\0';}string& string::operator+=(char ch){push_back(ch);return *this;}void string::append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){//大于二倍，需要多少开多少，小于二倍，就按二倍扩reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);}strcpy(_str + _size, str);//从\0开始拷贝，\0会自动被挤到后面_size += len;}string& string::operator+=(const char* str){append(str);return *this;}void string::insert(size_t pos, char ch){assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}//挪动数据/*size_t end = _size;while (end >= pos){_str[end + 1] = _str[end];--end;}*///挪动数据size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}//挪动完数据后再插入_str[pos] = ch;++_size;}void string::insert(size_t pos, const char* str){assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}size_t len = strlen(str);size_t end = _size + len;while (end >= pos + len){_str[end] = _str[end - len];--end;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;}void string::erase(size_t pos, size_t len){if (len >= _size - pos){_str[pos] = '\0';_size = pos;}else{for (size_t i = pos + len; i <= _size; i++){_str[i - len] = _str[i];}_size -= len;}}size_t string::find(char ch, size_t pos){assert(pos < _size);for (size_t i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;}size_t string::find(const char* str, size_t pos){assert(pos < _size);const char* ptr = strstr(_str + pos, str);if (ptr == nullptr){return npos;}else{return ptr - _str;}}string string::substr(size_t pos = 0, size_t len){assert(pos < _size);if (len > _size - pos){len = _size - pos;}string sub;sub.reserve(len);for (size_t i = 0; i < len; i++){sub += _str[pos + i];}return sub;}bool operator<(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) < 0;}bool operator<=(const string& s1, const string& s2){return s1 == s2 || s1 < s2;}bool operator>(const string& s1, const string& s2){return !(s1 <= s2);}bool operator>=(const string& s1, const string& s2){return !(s1 < s2);}bool operator!=(const string& s1, const string& s2){return !(s1 == s2);}bool operator==(const string& s1, const string& s2){return strcmp(s1.c_str(), s2.c_str()) == 0;}ostream& operator<<(ostream& out, const string& s){for (auto ch : s){out << ch;}return out;}istream& operator>>(istream& in, string& s){s.clear();//创造一块缓冲const int N = 256;char buffer[N];int i = 0;char ch;ch = in.get();while (ch != ' ' && ch != '\0'){buffer[i++] == ch;if (i == N - 1)// buffer条件{buffer[i] = '\0';s += buffer;i = 0;}if (i > 0){buffer[i] = '\0';s += buffer;}return in;}}void test_string1(){string s1;string s2("hello world");cout << s1.c_str() << endl;cout << s2.c_str() << endl;for (size_t i = 0; i < s2.size(); i++){s2[i] += 2;}cout << s2.c_str() << endl;}void test_string2(){string s1("hello world");s1 += '!';s1 += '#';cout << s1.c_str() << endl;s1 += "renqing";cout << s1.c_str() << endl;s1.insert(0, '#');cout << s1.c_str() << endl;string s2("hello world");s2.insert(5, "big");cout << s2.c_str() << endl;s2.erase(5, 3);cout << s2.c_str() << endl;}}

test.cpp

#define   _CRT_SECURE_NO_WARNINGS 1
#include"string.h"
int main()
{//sg::test_string1();sg::test_string2();return 0;
}