string的模拟实现
string的模拟实现
- MyString.h
- Test.cpp
MyString.h
1、构造函数、析构函数、迭代器
#pragma once
namespace JPC
{
//string 管理动态增长（在堆区开辟空间）的字符数组的一个类
// string是扩展版的顺序表，操控的是字符串（以 '\0' 结尾）
class string
{
public:
//string迭代器的模拟实现:像指针一样的东西
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
//构造函数
string(const char* str = "\0") //常量字符串(空串) "" ，里面默认包含了 '\0'
//:_str(new char[strlen(str) + 1]) //_str指向的空间，包含了'\0'
//, _size(strlen(str))
//, _capacity(strlen(str)) //开的空间：capacity只包含有效字符的空间，不包含'\0'的空间
{
_size = strlen(str);
_capacity = _size;
_str = new char[_size + 1];
strcpy(_str, str);
}
//析构函数
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
2、拷贝构造
//拷贝构造函数1 (进行深拷贝)
// s2(s1)【传统思维，员工思维】
//string(const string& s)
// :_str(new char[s._capacity+1]) // _capacity为 string存储有效字符的容量，而 +1 是给 /0 开辟的空间
// ,_size(s._size)
// ,_capacity(s._capacity)
//{
// strcpy(_str,s._str); //再把 字符串内容 拷贝过来
//}
//拷贝构造2
//s2(s1)【现代思维，老板思维：复用已经写好的函数】
void swap(string& tmp)
{
::swap(_str, tmp._str); //swap会优先在局部域里面找，找不到再到全局域里面找（这儿加了 域作用解析符 -- ::(全局的)）。
::swap(_size, tmp._size);
::swap(_capacity, tmp._capacity);
}
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0) //在这儿初始化 *this，后面和tmp交换之后，tmp才能顺利析构（否则swap给tmp的都是随机值，无法通过析构函数）。
{
string tmp(s._str); //复用 构造函数
swap(tmp);
}
3、赋值
//赋值1
// s1=s3【传统思维，员工思维】;
//string& operator=(const string& s)
//{
// if(this != &s) // &s 为取地址 (排除自己给自己赋值)
// {
// delete[] _str; //释放的是：指针指向的空间：_str, 而不是释放对象
// _str = new char[s._capacity + 1];
// strcpy(_str, s._str); //把 字符数组内容 拷贝过去
// _capacity = s._capacity;
// _size = s._size;
// }
// return *this;
//}
//赋值2
// s1=s3【现代思维，老板思维】
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s); //复用 拷贝构造函数
swap(tmp); // swap(*this,tmp);
}
return *this;
}
//赋值3
// s1=s3【超现代思维，nb老板思维：利用甲方帮自己赚钱】
//void swap(string& tmp)
//{
// ::swap(_str, tmp._str); //swap会优先在局部域里面找，找不到再到全局域里面找（这儿加了 域作用解析符 -- ::(全局的)）。
// ::swap(_size, tmp._size);
// ::swap(_capacity, tmp._capacity);
//}
//string& operator=(string s) // 传过来的是s3的拷贝构造，出了作用域就销毁了。
//{
// swap(s);
// return *this;
//}
4、返回 C字符串形式、_size 、_capacity
以及 operator [ ]
const char* c_str()const
{
return _str;
}
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
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、预先开空间
void reserve(size_t n) //预先开n个byte的空间，避免多次扩容造成消耗。
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n, char ch = '\0')
{
if (n > _size)
{
//插入数据
reserve(n);
for (size_t i = _size; i < n; ++i)
{
_str[i] = ch;
}
_str[n] = '\0';
_size = n;
}
else //删除数据
{
_str[n] = '\0';
_size = n;
}
}
6、增加
//增加
void push_back(char c)
{
先判断是否需要扩容
//if (_size == _capacity)
//{
// reserve(_capacity == 0 ? 4 : _capacity * 2);
//}
//_str[_size] = c;
//++_size;
//_str[_size] = '\0';
insert(_size, c);
}
void append(const char* str)
{
//size_t len = strlen(str);
满了就扩容
//if (_size+len > _capacity)
//{
// reserve(_size+len);
//}
//strcpy(_str+_size,str); //将str指向的内容 拷贝到 _str指向的字符数组的第 _size个位置
//_size += len;
insert(_size, str);
}
void append(const string& s)
{
append(s._str);
}
string& operator+=(char c) //直接复用 push_back
{
push_back(c); //相当于：this->push_back(c);
return *this;
}
string& operator+=(const char* str) // 复用 append
{
append(str); //相当于: this->append(str);
return *this;
}
string& operator+=(const string& s)
{
append(s._str);
return *this;
}
string& insert(size_t pos, char ch)
{
assert(pos <= _size);
//满了就扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
//挪动 pos及其后面的数据
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 (end >= pos + len)
{
// 有极端的坑（自己找）
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
7、删除
//删除
void erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
if (len == npos || pos + len >= _size) //将pos及其以后位置的字符都删除完
{
_str[pos] = '\0';
_size = pos;
}
else
// 将pos及以后位置的字符删除部分
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
}
//清除
void clear()
{
_str[0] = '\0';
_size = 0;
}
8、查找
//查找
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(sub);
assert(pos < _size);
const char* ptr = strstr(_str + pos, sub);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
//取子串:从pos位置开始，取得长度为len的子串，并返回
string substr(size_t pos, size_t len = npos)const
{
assert(pos < _size);
size_t realLen = len; //正常情况下，realLen = len
if (len == npos || pos + len > _size) //当len超标时，realLen就取完字符串。
{
realLen = _size - pos;
}
string sub;
for (size_t i = pos; i < (pos + realLen); ++i)
{
sub += _str[i];
}
return sub;
}
9、判断字符串的大小关系
//判断字符串的大小关系
bool operator>(const string& s)const
{
return strcmp(_str, s._str) > 0;
}
bool operator==(const string& s)const
{
return strcmp(_str, s._str) == 0;
}
bool operator>=(const string& s)const
{
return *this > s || *this == s;
}
bool operator<=(const string& s)const
{
return !(*this > s);
}
bool operator<(const string& s)const
{
return !(*this >= s);
}
bool operator!=(const string& s)const
{
return !(*this == s);
}
private:
// VS下:
// char _buff[16]; 在string类的内部默认开了16个字节大小的字符数组；
// < 16 字符串存在buff数组中{以空间换时间}
// >= 16 存在 _str指向的堆空间上
char* _str;
size_t _size;
size_t _capacity;
const static size_t npos = -1; // C++的特殊用法
//static size_t npos;
};
//size_t string::npos = -1;
10、输出、输入操作符
// 输出运算符(输出string类型的对象) 模拟实现
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); ++i)
{
out << s[i];
}
return out;
}
//输入运算符（输入string类型的对象）
istream& operator>>(istream& in, string& s)
{
s.clear();
//输入字符串很长，不断+=, 频繁扩容，效率很低，可以优化一下。
char ch;
//in >> 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;
i = 0;
}
ch = in.get();
}
buff[i] = '\0';
s += buff;
return in;
}
11、测试实现的string类 模拟函数
void test_string1()
{
string s1("hello world");
string s2;
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;
for (size_t i = 0; i < s1.size(); ++i)
{
cout << s1[i] << " ";
}
cout << endl;
for (size_t i = 0; i < s1.size(); ++i)
{
s1[i]++;
}
}
void test_string2()
{
string s1("hello world");
string::iterator it = s1.begin();
while (it != s1.end())
{
*it += 1; //可写
cout << *it << " "; //可读
++it;
}
cout << endl;
//for (auto ch : s1) //范围for的底层是迭代器，模拟了迭代器的底层,范围for的功能也就实现了。
//{
// cout<< ch <<" ";
//}
//cout << endl;
for (auto ch : s1)
{
cout << ch << endl;
}
}
void test_string3()
{
string s1("hello,world");
//string s2(s1); //如果不写构造函数，编译器会自动生成默认拷贝构造函数，而默认拷贝构造函数对内置类型的成员只进行浅拷贝（从而造成s1 s2两个成员对象的指针指向同一块儿空间）
//cout << s1.c_str() << endl;
//cout<< s2.c_str() <
//s2[0] = 'x';
//cout << s1.c_str() << endl;
//cout << s2.c_str() << endl;
string s3("1111111111111111111");
s1 = s3;
}
void test_string4()
{
string s1("hello,world");
string s2("xxxxxxx");
s1.swap(s2); //局部域的swap；也就是std::string::swap
swap(s1, s2); //全局域的swap（对于深拷贝的类型，代价很大）
}
//增加
void test_string5()
{
string s1("hello");
cout << s1.c_str() << endl;
s1.push_back('x');
cout << s1.c_str() << endl;
cout << s1.capacity() << endl;
s1 += 'y';
s1 += 'y';
s1 += 'y';
s1 += 'y';
s1 += 'y';
s1 += 'y';
cout << s1.c_str() << endl;
cout << s1.capacity() << endl;
}
//增加
void test_string6()
{
string s1("hello");
cout << s1.c_str() << endl;
s1 += ' ';
s1.append("bit");
s1 += " and world.";
cout << s1.c_str() << endl;
}
void test_string7()
{
string s1("hello");
cout << s1.c_str() << endl;
s1.insert(2, "world");
cout << s1.c_str() << endl;
s1.insert(0, "world");
cout << s1.c_str() << endl;
}
void test_string8()
{
string s1("hello");
s1.erase(1, 10);
cout << s1.c_str() << endl;
string s2("hello");
s2.erase(1);
cout << s2.c_str() << endl;
string s3("hello");
s3.erase(1, 2);
cout << s3.c_str() << endl;
}
void test_string9()
{
string s1("hello");
cout << s1 << endl; // operator<<(cout,s1)
cout << s1.c_str() << endl;
s1 += '\0';
s1 += "world";
cout << s1 << endl;
cout << s1.c_str() << endl;
string s3, s4;
cin >> s3 >> s4;
cout << s3 << endl;
cout << s4 << endl;
}
void test_string10()
{
string url1 = "https://cplusplus.com/reference/string/string/";
cout<< url1.find('c') << endl;
cout << url1.find('c',9) << endl;
cout<< url1.find("plus") << endl;
cout << url1.find("plus",10) << endl;
cout<< (url1.substr(8,9)).c_str() <<endl;
}
void test_string11()
{
string s1;
s1.resize(20); // resize不仅会改变 _capacity,也会改变 _size
string s2("hello");
s2.resize(10, 'x');
string s3("1111111111");
s3.resize(5);
}
}
Test.cpp
#define _CRT_SECURE_NO_WARNINGS
#include