上次讲了常用的接口：C++初阶：初识STL、String类接口详细讲解（万字解析）
今天就来进行模拟实现啦
文章目录
- 1.基本结构与文件规划
- 2.构造函数（constructor)
- 2.1构造函数
- 2.1.1无参有参分开
- 2.1.2利用缺省参数合起来
- 2.2拷贝构造
- 2.3模拟c_str()函数
- 3.析构函数（destructor）
- 4.operator=
- 5.迭代器（iterator）
- 6.1size()与capacity()
- 6.2 reserve()函数
- 7. modify
- 7.1push_back()、append()和operator+=
- 7.2clear()和swap()
- 8.access（operator[]）
- 9.npos
- 10.find()函数
- 11.insert()和erase()
- 13.operator<<和operator>>
先看一下大概有哪些部分：
1.基本结构与文件规划
- string.h头文件：包含类的全部(函数的声明与定义)
- test.cpp源文件：进行调用test函数，测试和完善功能
基本结构：
namespace MyString
{
class string
{
public:
//各种函数
private:
int _size;//有效字符的数量
int _capacity;//开的空间大小
char* _str;//没有设计成模版，就直接用char数组了
};
}
2.构造函数（constructor)
2.1构造函数
2.1.1无参有参分开
string()//空参的
{
_size = 0;
_capacity = 0;
_str = new char[1];
_str[0] = '\0';
}
string(const char* str)
{
_size = strlen(str);
_capacity = _size;
_str = new char[_size + 1];//加一是给 \0
strcpy(_str, str);
}
2.1.2利用缺省参数合起来
string(const char* str="")//不是" "
{
_size = strlen(str);
_capacity = _size;
_str = new char[_size + 1];//加一是给 \0
strcpy(_str, str);
}
2.2拷贝构造
string(const string& s)
{
_size = s._size;
_capacity = s._capacity;
_str = new char[_capacity + 1];
strcpy(_str, s._str);
}
2.3模拟c_str()函数
目前还没有进行流插入和流提取的重构，只能利用这个来输出string里的内容
const char* c_str()const
{
return _str;
}
利用test1函数来看是否正确：
相同的命名空间会进行合并的
namespace MyString
{
void test1()
{
string s1;
cout << s1.c_str() << endl;
string s2("abc");
cout << s2.c_str() << endl;
string s3(s2);
cout << s3.c_str() << endl;
}
}
int main()
{
MyString::test1();
return 0;
}
3.析构函数（destructor）
~string()
{
_size = _capacity = 0;
delete[] _str;
_str = nullptr;
}
4.operator=
string& operator=(const string& s)//创建好新的空间（复制跟赋值）。再清理旧空间指向新的
{
char* tmp = new char[s._capacity+1];//创建好新空间
strcpy(tmp, s._str);
_size = s._size;
_capacity = s._capacity;//复制跟赋值
delete[] _str;
_str = tmp;//清理，指向新的
return *this;
}
5.迭代器（iterator）
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;
}
#6.capacity
6.1size()与capacity()
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
6.2 reserve()函数
void reserve(size_t n)
{
if (n > _capacity)
{
_capacity = n;
char* tmp = new char[_capacity + 1];
strcpy(tmp, _str);
delete[]_str;
_str = tmp;//指向新的
}
}
namespace MyString
{
void test2()
{
string s1;
cout << s1.size() << endl;
string s2("abc");
cout << s2.size() << endl;
string s3;
s3 = s2;
cout << s3.size() << endl;
cout << s3.capacity() << endl;
}
}
int main()
{
MyString::test2();
return 0;
}
7. modify
7.1push_back()、append()和operator+=
void push_back(char c)
{
if (_size == _capacity)
{
int newCapacity = _capacity == 0 ? 4 : 2 * _capacity;//有可能是空参构造
reserve(newCapacity);
}
_str[_size++] = c;
_str[_size] = '\0';
}
void append(const char* str)
{
int len = strlen(str);
if (len + _size > _capacity)
{
reserve(len + _size);
}
strcpy(_str + _size, str);
_size += len;
}
string& operator+=(char c)
{
push_back(c);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
这里其实大家也能看到，二者一个用于字符的添加，一个用于字符串的添加。
其实就可以一个写成另外一个的重载
7.2clear()和swap()
void clear()
{
_size = 0;
_str[0] = '\0';
}
void swap(string& s)
{
std::swap(*this, s);//使用库里的swap
}
对于swap，我们可以去使用库里面的，加上std：：就行了
namespace MyString
{
void test3()
{
string s1("abc");
cout << s1.c_str() << endl;
s1 += 'a';
cout << s1.c_str() << endl;
s1 += "xxx";
cout << s1.c_str() << endl;
}
}
int main()
{
MyString::test3();
return 0;
}
8.access（operator[]）
char& operator[](size_t index)
{
return _str[index];
}
const char& operator[](size_t index)const
{
return _str[index];
}
一个用于非常量，一个用于常量
9.npos
namespace MyString
{
class string
{
public:
//各种函数
private:
int _size;//有效字符的数量
int _capacity;//开的空间大小
char* _str;//没有设计成模版，就直接用char数组了
static size_t npos;
};
size_t string::npos = -1;
}
10.find()函数
// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const//默认从0开始找
{
for (int i = 0; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
}
return npos;
}
// 返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos = 0) const
{
char* ret = strstr(_str, s);//返回第一次出现的位置
if (ret == nullptr)//没找到
{
return npos;
}
return ret - _str ;
}
namespace MyString
{
void test4()
{
string s1("abc");
cout << s1.find('a') << endl;
cout << s1.find("bc");
}
}
int main()
{
MyString::test4();
return 0;
}
11.insert()和erase()
// 在pos位置上插入字符c/字符串str，并返回该字符的位置
string& insert(size_t pos, char c)
{
if (_size = _capacity)//先看空间够不够
{
int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
reserve(newcapacity);
}
//先向后移一格
int end = _size;// \0也往后
while (end >= (int)pos)//pos一般为size_t类型，此时，end会整型提升（有符号整数类型会被提升为无符号整数类型。）
{
_str[end + 1] = _str[end];
end--;
}
_str[pos] = c;
_size++;
return *this;
}
string& insert(size_t pos, const char* str)
{
int len = strlen(str);
if (_size +len>= _capacity)
{
reserve(_size + len);
}
//先向后移len个格
int end = _size;// \0也往后
while (end >= (int)pos)
{
_str[end + len] = _str[end];
end--;
}
strncpy(_str + pos, str,len);
_size += len;
return *this;
}
// 删除pos位置上的元素，并返回该元素的下一个位置
string& erase(size_t pos, size_t len= npos)
{
if (len == npos || len + pos >= _size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
int start = pos;
while (_size - start - len+1 > 0)
{
_str[start] = _str[start + len];
start++;
}
}
return *this;
}
测试：
namespace MyString
{
void test5()
{
string s1("abc");
cout << s1.c_str() << endl;
int pos = s1.find("bc");
s1.insert(pos, "xxx");
cout << s1.c_str() << endl;
s1.erase(pos,2);
cout << s1.c_str() << endl;
}
}
int main()
{
MyString::test5();
return 0;
}
#12.substr()函数
string substr(size_t pos, size_t len = npos)
{
int end = pos + len;//end作为结束位置
if (len == npos || pos + len >= _size)
{
end = _size;//当这两种情况，结束位置就是最后\0了
}
//开始pos到end赋值到新的一个空间，再返回
string s;
reserve(end - pos);
for (int i = pos; i < end; i++)
{
s += _str[i];
}
return s;
}
13.operator<<和operator>>
ostream& operator<<(ostream& out, string& s)//不需要放在类内，不需要是友元
{
for (auto e : s)
{
out << e;
}
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = in.get();//使用cin拿不到空格和换行，二者其实还是字符，就用这个get
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
测试：
namespace MyString
{
void test6()
{
string s1;
cin >> s1;
cout << s1 << endl;
int pos = s1.find('b');
string s2 = s1.substr(pos, 2);
cout << s2 << endl;
}
}
int main()
{
MyString::test6();
return 0;
}
好啦，今天就到这里啦，感谢大家支持！！！
