C++string类重要函数模拟实现
为了和C++标准库区分，以下代码除主函数外均在namespace空间
目录
一.成员
二、带参构造函数
三、拷贝构造函数和赋值运算符重载
四、析构函数
五、重要成员函数实现
1. c_str函数
2. operator[]重载
3. size函数和capacity函数
4.reverse函数
5. push_back和append函数
6. operator+=重载
7. insert函数
8. erase函数
9. clear函数
10.resize函数
11.find函数
12.substr函数
六、迭代器
七、全局函数
1.operator判断符重载
2.流输入和流输出运算符重载
一.成员
首先一定要有个字符指针 _str，指向所存放的字符串。
还需要有字符串的大小_size，能够快速的知道这个字符串多大。
再需要有字符串的容量_capacity，知道字符串追加后是否需要扩容。
因此我们定义
class string
{
private:
char* _str;
size_t _size;
size_t _capacity;
}二、带参构造函数
构造函数使用的是字符串来构造，并且给缺省值 "" ，注意里面没有空格，为了能够进行默认构造，并且这是一个字符串，虽然没有给到什么内容，但会存放一个'\0'。
_size和_capacity的大小就是str的长度。
_str需要使用new来开辟空间，开辟空间的大小是_capacity+1，因为之前strlen(str)算出来的长度都没有算'\0'，因此你需要多开辟一个空间来存放'\0';
string(const char* str = "")
:_size(strlen(str))
,_capacity(_size)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}三、拷贝构造函数和赋值运算符重载
为了实现深拷贝，就需要自己写拷贝构造和赋值运算符重载。
这里的拷贝构造函数和赋值我们选用了很简单的写法，使用带参构造函数构造出一个临时的类对象tmp，这个tmp对象的值正好是当前对象需要的，因此将他们两个交换一下，当前对象就完成了深拷贝了，同时tmp也会出了作用域也会自动调用析构函数进行析构（析构函数马上就写）。
赋值运算符重载也是利用的这种思想，甚至更加简单粗暴，不用为了节约而传 const string& s了，直接传string tmp，这样会调用一次拷贝构造，我要的就是拷贝出来的临时对象跟我互换，换了之后返回*this 即可
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0) //保证编译器一定初始化，析构才不会出错
{
string tmp(s._str);
swap(tmp);
}
string& operator=(string tmp)
{
swap(tmp);
return *this;
}四、析构函数
析构函数非常简单，只需要将_str里面的内容delete掉即可，注意是需要delete[] ，顺便将_str置空， _size 和 _capacity赋值给0。
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}五、重要成员函数实现
1. c_str函数
c_str()是将string类对象转化为字符串的格式，方便我们打印操作.
代码只需返回_str即可。
const char* c_str() const
{
return this->_str;
}
2. operator[]重载
为了让string类对象像数组一样访问，我们需要重载 []
代码也很简单。这里写了两个版本，一个普通版一个const版，这为了让普通对象调用可以修改，const类对象的调用不能修改
char& operator[](size_t pos)
{
assert(pos >= 0 && pos <= _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos >= 0&&pos<=_size);
return _str[pos];
}
3. size函数和capacity函数
让类外访问到private成员_size和_capacity的值。
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}4.reverse函数
reverse是扩容，如果n比_capacity小就不管，比_capacity打就按照n的大小来扩容。
流程为开辟空间，拷贝数据，释放空间，指向新空间，_capacity变为0
void reverse(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n+1];//要多开一个留给'\0'
strcpy(tmp, _str);
if(_str!=nullptr)
delete[] _str;
_str = tmp;
_capacity = n;
}
}5. push_back和append函数
push_back是在尾部插入一个字符，插入之前判断空间是否足够，不足就扩容再插入，_size需要++，注意后面要置为'\0'。
append是在尾部插入一个字符串，依然要判断是否扩容，使用了库函数来进行拷贝，strcpy会拷贝'\0'，因此无需关心'\0'，将_size+=len即可
void push_back(char ch)
{
if (_size == _capacity)
{
reverse(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reverse(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}6. operator+=重载
使用+=比push_back和append爽的多，还不需要关心是字符还是字符串，因为我们运算符重载加函数重载了。
代码部分分别调用即可。
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
7. insert函数
insert函数运用了重载，可以在你想要的位置插入字符和字符串。
他的主要思想是从后往前遍历，并且将数据往后面挪动，直到到了pos位置才会停止，然后将要插入的字符或者字符串放在pos位置即可。
只需要注意字符移动一格，字符串移动len格。
void insert(size_t pos,char ch)
{
assert(pos <= _size && pos >= 0);
if (_size == _capacity)
{
reverse(_capacity == 0 ? 4 : 2 * _capacity);
}
for(size_t i = _size + 1; i > pos; i--)
{
_str[i] = _str[i - 1];
}
_str[pos] = ch;
_size++;
}
void insert(size_t pos, const char* str)
{
assert(pos <= _size && pos >= 0);
size_t len = strlen(str);
if (len+_size > _capacity)
{
reverse(len + _size);
}
for (size_t i = _size + len; i > pos; i--)
{
_str[i] = _str[i - len];
}
memcpy(_str + pos, str, len);
_size += len;
}8. erase函数
erase函数要分两种情况
一种是len的长度要大于等于_size-pos，也就是说要将pos后面的内容全部删除，这种我们处理起来很简单，将pos位置直接置为'\0'，同时_size = pos即可。
另一种是后面还有字符需要保留，需要将后面的字符挪动到pos位置这里来，再_size -= len;
这里参数缺省值npos是静态成员函数，类型为size_t，值为-1，代表int的最大值
void erase(size_t pos,size_t len = npos)
{
assert(pos < _size && pos >= 0);
if (len >= _size - pos)
{
_size = pos;
_str[_size] = '\0';
}
else
{
for (size_t i = pos + len; i <= _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}9. clear函数
clear函数简单，不需要处理_capacity，只需要第一个字符给到'\0'，将_size给0。
void clear()
{
_str[0] = '\0';
_size = 0;
}10.resize函数
resize也是两种情况
n小于等于_size时，证明_size要减小，直接在n这个位置给到'\0'，_size给0就好
另一种情况就可能需要扩容了，我们直接暴力处理，不管你扩不扩容，先来个reverse(n)，要扩容我就扩容，不需要我就返回继续执行后续代码，同时给后面的空间都赋值ch。不要忘记最后_size给0，还有最后给'\0'。
void resize(size_t n,char ch = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
_size = n;
}
else
{
reverse(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
}11.find函数
find函数重载了，可以从某位位置往后找字符，或者字符串。
找字符很简单，一个循环完事。
找字符串用到了strstr()函数，不为空代表找到了，就返回找到的指针- _str指针，就能算出他们两个的差值，就是索引，指针为空就返回 npos。
size_t find(char ch,size_t pos = 0)
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
const char* p = strstr(_str + pos, str);
if (p)
{
return p - _str;
}
return npos;
}12.substr函数
substr是从pos位置，截取n个长度的字符串，返回类型为string
如果n == pos||n>=_size-pos即代表pos后面的长度都要截取到，算出pos后面还有多少个字符，给s开辟好空间，遍历直接直接+=即可。
另一种情况，就遍历到 pos + n，再进行+=
string substr(size_t pos, size_t n = npos)
{
string s;
if (n == npos || n >= _size - pos)
{
n = _size - pos;
s.reverse(n);
for (size_t i = pos; i < _size; i++)
{
s += _str[i];
}
}
else
{
s.reverse(n);
for (size_t i = pos; i < pos + n; i++)
{
s += _str[i];
}
}
return s;
}六、迭代器
迭代器是STL的特性，string类虽然比STL要早一点，还后面还是支持了迭代器，只不过因为该有的功能都有了，迭代器没有那么重要，但是可以为我们后续学其他容器打好基础。
string类的迭代器非常简单，就是一个指针，只需要写好begin() 和 end()就可以进行范围for的遍历了，指针本身就支持++和解引用，因此不需要重载。
我们写了两个迭代器，普通迭代器可以修改，const 迭代器不能修改
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;
}七、全局函数
1.operator判断符重载
调用strcmp，再加复用
下面6种判断符重载，可以写在类里面，但string类为了支持宽字符等其他字符，写出了全局函数，这里只支持char类型，但还是写出了全局函数
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 strcmp(s1.c_str(), s2.c_str()) > 0;
}
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);
}
bool operator>=(const string& s1, const string& s2)
{
return !(s12.流输入和流输出运算符重载
流输出非常简单，直接遍历即可。
这里使用get()函数才可以获取到' '(空格)和'\n'(换行)
我们使用了临时数组来存储，目的是为了减少扩容，因为扩容的消耗很大。一个一个放到数组里面，等获取到' '(空格)和'\n'(换行) ，或者数据满了之后，再从数组里面将数据提取出来。
ostream& operator<<(ostream& out, const string& s)
{
//out << s.c_str() << endl;
for (auto e : s)
{
out << e;
}
return out;
}
istream& operator>>(istream& in,string& s)
{
s.clear();
char tmp[129];
size_t i = 0;
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
tmp[i++] = ch;
if (i == 128)
{
tmp[i] = '\0';
s += tmp;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
tmp[i] = '\0';
s += tmp;
}
return in;
}到此，我们程序终于完成了，最后放上总代码
string.h
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
using namespace std;
namespace kky
{
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)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}
//传统
//string(const string& s)
// :_size(s._size)
// ,_capacity(s._capacity)
//{
// _str = new char[_capacity + 1];
// strcpy(_str, s._str);
//}
//string& operator=(const string& s)
//{
// if (this != &s)
// {
// char* tmp = new char[s._capacity + 1];
// strcpy(tmp, s._str);
// delete[] _str;
// _str = tmp;
// _size = s._size;
// _capacity = s._capacity;
// }
// return *this;
//}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0) //保证编译器一定初始化，析构才不会出错
{
string tmp(s._str);
swap(tmp);
}
string& operator=(string tmp)
{
swap(tmp);
return *this;
}
const char* c_str() const
{
return this->_str;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
char& operator[](size_t pos)
{
assert(pos >= 0 && pos <= _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos >= 0&&pos<=_size);
return _str[pos];
}
size_t find(char ch,size_t pos = 0)
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
const char* p = strstr(_str + pos, str);
if (p)
{
return p - _str;
}
return npos;
}
string substr(size_t pos, size_t n = npos)
{
string s;
if (n == npos || n >= _size - pos)
{
n = _size - pos;
s.reverse(n);
for (size_t i = pos; i < _size; i++)
{
s += _str[i];
}
}
else
{
s.reverse(n);
for (size_t i = pos; i < pos + n; i++)
{
s += _str[i];
}
}
return s;
}
void reverse(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];//要多开一个留给'\0'
strcpy(tmp, _str);
if (_str != nullptr)
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size == _capacity)
{
reverse(_capacity == 0 ? 4 : 2 * _capacity);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reverse(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
void insert(size_t pos,char ch)
{
assert(pos <= _size && pos >= 0);
if (_size == _capacity)
{
reverse(_capacity == 0 ? 4 : 2 * _capacity);
}
for(size_t i = _size + 1; i > pos; i--)
{
_str[i] = _str[i - 1];
}
_str[pos] = ch;
_size++;
}
void insert(size_t pos, const char* str)
{
assert(pos <= _size && pos >= 0);
size_t len = strlen(str);
if (len+_size > _capacity)
{
reverse(len + _size);
}
for (size_t i = _size + len; i > pos; i--)
{
_str[i] = _str[i - len];
}
memcpy(_str + pos, str, len);
_size += len;
}
void erase(size_t pos,size_t len = npos)
{
assert(pos < _size && pos >= 0);
if (len >= _size - pos)
{
_size = pos;
_str[_size] = '\0';
}
else
{
for (size_t i = pos + len; i <= _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}
void clear()
{
_str[0] = '\0';
_size = 0;
}
void resize(size_t n,char ch = '\0')
{
if (n <= _size)
{
_str[n] = '\0';
_size = n;
}
else
{
reverse(n);
for (size_t i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
}
private:
char* _str;
size_t _size;
size_t _capacity;
//const static size_t npos = -1; //特例
const static size_t npos;
};
const size_t string::npos = -1;
ostream& operator<<(ostream& out, const string& s)
{
//out << s.c_str() << endl;
for (auto e : s)
{
out << e;
}
return out;
}
istream& operator>>(istream& in,string& s)
{
s.clear();
char tmp[129];
size_t i = 0;
char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
tmp[i++] = ch;
if (i == 128)
{
tmp[i] = '\0';
s += tmp;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
tmp[i] = '\0';
s += tmp;
}
return in;
}
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 strcmp(s1.c_str(), s2.c_str()) > 0;
}
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);
}
bool operator>=(const string& s1, const string& s2)
{
return !(s1> s1;
cout << s1.c_str() << endl;
}
void test05()
{
string s1("hello world");
cout << s1.c_str() << endl;
string s2("hello worldl");
cout << s2 << endl;
s1.resize(5);
cout << s1 << endl;
s1.resize(15,'c');
cout << s1 << endl;
}
void test06()
{
string s1("hello world");
string s2(s1);
cout << s1 << endl;
cout << s2 << endl;
string s3 = "wasg1";
s3 = s1;
cout << s3 << endl;
}
}
test.cpp （调用测试接口即可）
#include"string.h"
int main()
{
kky::test06();
}