【C++】---string的模拟

【C++】---string的模拟

一、string类实现1.string类的构造函数2.swap（）函数3.拷贝构造函数4.赋值运算符重载5.析构6.迭代器7.operator[ ]8.size9.c_str（）10.reserve（）11.resize（）12.push_back（）13.append（）14.operator+=（）15.insert（）16.erase（）17.find（）18.operator>19.operator==20.operator>=21.operator<22.operator<=23.operator!=24.clear（）25.substr的模拟：(从字符串中截取一段长度len的子字符串！)26.getline函数的模拟：27.operator<<28.operator>>完整代码段：

一、string类实现

为了将自己命名的string类和库里面的string类区分开来，我们用命名空间namespace yjl 区分开
string类里面有成员函数:（1）_ str:字符串内容（2）_ size:字符串大小（3）_ capacity:字符串容量、

namespace yjl{class string{    private:        char* _str;    size_t _size;    size_t _capacity;    };}

1.string类的构造函数

分配空间时，要多分配1个字节的空间，这1个字节是留给’\0’的，_size最大为申请字节数-1，_capacity最大也为申请字节数-1

// 方法1：在初始化列表里面调用太多的strlen！！！效率不高!/*string(const char* str=" "):_size(strlen(str)),_str(new char[strlen(str)+1]),_capacity(strlen(str))  // 在初始化列表里面调用太多的strlen！！！{}*/// 1.构造函数//string(const char* str = nullptr) //这里的str不能给nullptr，因为strlen（nullptr）会出错！//string(const char* str = "\0")// 不能是'\0'因为'\0'是char类型，不能赋值给char* 类型的！而"\0"就是空串！ 可以string(const char* str = " ")// 官方的写法！空串里面就默认有一个'\0':_size(strlen(str)){_str = new char[_size + 1];_capacity = _size;strcpy(_str, str);}

2.swap（）函数

使用库里的swap函数交换*this和s的内容：包括_str字符串内容、_size字符串大小和_capacity字符串容量

// swap的模拟：void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}

3.拷贝构造函数

（1）传统写法：

// 17.拷贝构造函数// (1) 传统写法：(必须是深拷贝)// s1(s2)string(const string& s){// 因为是深拷贝，所以要用new新开辟一块空间_str = new char [s._capacity+1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}

（2）现代写法：

// (2)现代写法：// s1(s2)string(const string& s){string tmp = s._str;// 直接调用构造函数，让构造函数来完成 空间的开辟 和 拷贝！//string tmp (s._str);swap(tmp);}

4.赋值运算符重载

（1）传统写法：

// (1)传统写法：// s1=s2string& operator=(const string& s){// 开多大的空间，要看你要把谁赋值给别人。这里就是s2!char* tmp = new char[s._capacity];strcpy(tmp,s._str);delete[] s._str;_str = tmp;// 更新参数_size = s._size;_capacity = s._capacity;return *this;}

（2）现代写法：

// (2)现代写法：复用，拷贝构造// (在写 赋值 的现代写法之前，你还要写一个拷贝构造函数的现代写法，因为他要复用)// s1=s2string& operator=(const string& s){string tmp(s);// 重载赋值函数 调用 拷贝构造，不会陷入死循环！// 只有拷贝构造自己调用拷贝构造才会陷入死循环！swap(tmp);return *this;}

5.析构

// 2.析构函数~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}

6.迭代器

分两种：普通迭代器（可读可写）和const迭代器（只读）

（1）普通迭代器：

iterator begin(){return _str;}iterator end(){return _str + _size;}

（2）const迭代器：

iterator begin()const{return _str;}iterator end()const{return _str + _size;}

7.operator[ ]

也分为普通operator[ ]（可读可写）和const operator[ ]（只读）

char要加&，如果不加，那么return就是传值返回，返回的是_str[i]的拷贝，即临时对象，而临时对象具有常性，不能被修改，只能读；如果要对_str进行修改的话，char要加&，用传引用返回

（1）普通：

// 可读可写char& operator[](size_t pos){assert(pos < _size);return _str[pos];}

（2）const：

// (3)[]的模拟：返回的是字符(有const，只读！！！)const char& operator[](size_t pos)const{assert(pos < _size);return _str[pos];}

8.size

//(2) size()函数的实现！(求string对象的大小)size_t size()const // 最好写成const，不仅普通对象可以调用，const对象也可以调用！{return _size;}

9.c_str（）

// 6.c_str(将 字符串 转化  字符)const char* c_str(){return _str;}

10.reserve（）

// 7.reserve 扩容（1）new新空间（2）拷贝字符串（3）释放旧空间（4）指向新空间（5）更新_capacityvoid reserve(size_t n){if (n > _capacity){// 1.new新空间char* tmp = new char[n + 1];// 2.拷贝字符串strncpy(tmp, _str, _size + 1);// 3.释放旧空间delete[] _str;// 4.指向新空间_str = tmp;// 5.更新_capacity_capacity = n;}}

11.resize（）

开空间+初始化，扩展_capacity，_size也要修改

（1）当n<_size，无需增容

（2）当n>_size，分两种情况
①_size < n <_capacity，无需增容，直接将_size到n位置置为val
②n >_capacity，需增容，并将_size到n位置置为val
n>_size的这两种情况只有是否增容的区别，其他没有区别，可以合二为一

        void resize(size_t n, char val = '\0')//如果没有显式给出val，val为\0{//1.当n<_size，无需增容if (n < _size){_size = n;//直接更新_size_str[_size] = '\0';//将_size位置置为\0}//2.当n>_size，分两种情况//（1）_size < n <_capacity，无需增容，直接将_size到n位置置为val//（2）n >_capacity，需增容，并将_size到n位置置为val//这两种情况只有是否增容的区别，其他没有区别else{if (n > _capacity){reserve(n);} for (size_t i = _size; i < n; i++){_str[i] = val;} _str[n] = '\0';//将n的位置置\0_size = n;//更新_size}}

12.push_back（）

// 8.push_back的模拟！(追加的是一个 字符！)void push_back(const char ch){// 扩容2倍if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;_size++;_str[_size] = '\0';}

13.append（）

// 9.append的模拟！(追加的是一个 字符串！)void append(const char* str){// 弹性扩容，直接计算str大小int n = strlen(str);if ((n + _size) > _capacity){reserve(n + _size);// 要多少就扩多少！}strcpy(_str + _size, str);_size += n;}

14.operator+=（）

//(1)operator+=重载:字符string& operator+=(char ch){push_back(ch);return *this;}//(2)operator+=重载:字符串string& operator+=(const char* str){append(str);return *this;}

15.insert（）

// 11.insert的模拟：// (1)字符void insert(size_t pos, char ch){assert(pos <= _size);// 扩容if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}// 法1： 下面这个while循环是挪pos后面位置的字符//int end = _size;// 你只要记住是 有符号(int) 自动转为 无符号(size_t) 就行了//while (end >= (int)pos) // 这里的无符号和有符号进行比较或者运算的时候，//// 直接把这个end的int直接转换成无符号(size_t)，无符号的时候如果pos等于0就会陷入无限循环!//{//_str[end + 1] = _str[end];//end--;//}/*_str[pos] = ch;_size++;*/// 法2：int end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;_size++;}// (2)字符串：void insert(size_t pos, const char* str){assert(pos <= _size);int len = strlen(str);if (len + _size > _capacity){reserve(len + _size);}int end = len + _size;// 这个只是挪动pos后面数据的过程！while (end > pos){_str[end] = _str[end - len];--end;}// 插入strncpy(_str + pos, str, len);_size = len+_size;}

16.erase（）

// 12.erase的模拟：void erase(size_t pos, size_t len = -1){assert(pos < _size);if (len == -1 || len >= _size - pos){_str[pos] = '\0';_size = pos;}else{strcpy(_str + pos, _str + pos + len);_size -= len;}}

17.find（）

// 14.find的模拟// (1)查找字符！size_t find(char ch, size_t pos)const// pos的意义就是：从哪个位置开始查找！{assert(pos <= _size);for (size_t i = pos; i < _size; i++){if (_str[i] == ch) {return i;}else{return -1;}}}// (2)查找字符串！size_t find(char* str, size_t pos)const// pos的意义就是：从哪个位置开始查找！{assert(pos < _size);const char* p = strstr(_str + pos, str);if (p){return p-_str;}else{return -1;}}

18.operator>

        bool operator>(const string& s){return strcmp(_str, s._str) < 0;}

19.operator==

    bool operator==(const string& s){return strcmp(_str, s._str) == 0;}

20.operator>=

    bool operator>=(const string& s){return (*this > s) || (*this == s);}

21.operator<

    bool operator<(const string& s){return !(*this >= s);}

22.operator<=

    bool operator<=(const string& s){return !(*this > s);}

23.operator!=

    bool operator!=(const string& s){return !(*this == s);}

24.clear（）

// 清理void clear(){_size = 0;_str[_size] = '\0';}

25.substr的模拟：(从字符串中截取一段长度len的子字符串！)

// substr的模拟：(从字符串中截取一段长度len的子字符串！)string substr(size_t pos, size_t len = -1){string sub;// (1)截取的长度len远超于字符串的总长度_sizeif (len >= _size - pos){for (size_t i = pos; i < _size; i++){sub += _str[i];}}else{//for (size_t i = pos; i < _size - pos; i++)for (size_t i = pos; i < pos+len; i++)//应该打印的是len个长度的！{sub += _str[i];}}return sub;}

26.getline函数的模拟：

// getline函数的模拟：istream& getline(istream& in, string& s){//1.先清理s.clear();char ch;// in>>chch = in.get();char buff[128];size_t i = 0;while (ch != '\n'){buff[i++] = ch;// buff[0,126]if (i == 127){buff[127] = '\0';s += buff;i = 0;//}ch = in.get();// // 走到此处：遇到了'\n' && 没有进去if(i==127)没有把数组填充满！if (i > 0)// buff[i] = '\0';s += buff;}return in;}

27.operator<<

// 重载 <<ostream& yjl::operator<<(ostream& out, const yjl::string& _str){for (size_t i = 0; i < _str.size(); i++){out << _str[i];}return out;}

28.operator>>

istream& operator>>(istream& in, string& s){s.clear();char ch;ch = in.get();while (ch != ' ' && ch != '\0'){s += ch;ch = in.get();}return in;}

完整代码段：

string.h（头文件）

#pragma once#include<string.h>#include<iostream>#include<assert.h>namespace yjl{class string{friend ostream& operator<<(ostream& out, const yjl::string& _str);private:char* _str;size_t _size;size_t _capacity;public:/*string(const char* str=" "):_size(strlen(str)),_str(new char[strlen(str)+1]),_capacity(strlen(str))  // 在初始化列表里面调用太多的strlen！！！{}*/typedef char* iterator;// 1.构造函数//string(const char* str = nullptr) //这里的str不能给nullptr，因为strlen（nullptr）会出错！//string(const char* str = "\0")// 不能是'\0'因为'\0'是char类型，不能赋值给char* 类型的！而"\0"就是空串！ 可以string(const char* str = " ")// 官方的写法！空串里面就默认有一个'\0':_size(strlen(str)){_str = new char[_size + 1];_capacity = _size;strcpy(_str, str);}// 2.析构函数~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}// 3.下标+[]：遍历// (1)capacity模拟size_t capacity(){return _capacity;}//(2) size()函数的实现！(求string对象的大小)size_t size()const // 最好写成const，不仅普通对象可以调用，const对象也可以调用！{return _size;}// (3)[]的模拟：返回的是字符(有const，只读！！！)const char& operator[](size_t pos)const{assert(pos < _size);return _str[pos];}// (4)可读可写char& operator[](size_t pos){assert(pos < _size);return _str[pos];}// 4.模拟迭代器：iterator begin(){return _str;}iterator end(){return _str + _size;}// 5.const 迭代器的模拟iterator begin()const{return _str;}iterator end()const{return _str + _size;}// 6.c_str(将 字符串 转化  字符)const char* c_str(){return _str;}// 7.reserve 扩容（1）new新空间（2）拷贝字符串（3）释放旧空间（4）指向新空间（5）更新_capacityvoid reserve(size_t n){if (n > _capacity){// 1.new新空间char* tmp = new char[n + 1];// 2.拷贝字符串strncpy(tmp, _str, _size + 1);// 3.释放旧空间delete[] _str;// 4.指向新空间_str = tmp;// 5.更新_capacity_capacity = n;}}// 8.push_back的模拟！(追加的是一个 字符！)void push_back(const char ch){// 扩容2倍if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;_size++;_str[_size] = '\0';}// 9.append的模拟！(追加的是一个 字符串！)void append(const char* str){// 弹性扩容，直接计算str大小int n = strlen(str);if ((n + _size) > _capacity){reserve(n + _size);// 要多少就扩多少！}strcpy(_str + _size, str);_size += n;}// 10.//(1)operator+=重载:字符string& operator+=(char ch){push_back(ch);return *this;}//(2)operator+=重载:字符串string& operator+=(const char* str){append(str);return *this;}// 11.insert的模拟：// (1)字符void insert(size_t pos, char ch){assert(pos <= _size);// 扩容if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}// 法1： 下面这个while循环是挪pos后面位置的字符//int end = _size;// 你只要记住是 有符号(int) 自动转为 无符号(size_t) 就行了//while (end >= (int)pos) // 这里的无符号和有符号进行比较或者运算的时候，//// 直接把这个end的int直接转换成无符号(size_t)，无符号的时候如果pos等于0就会陷入无限循环!//{//_str[end + 1] = _str[end];//end--;//}/*_str[pos] = ch;_size++;*/// 法2：int end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;_size++;}// (2)字符串：void insert(size_t pos, const char* str){assert(pos <= _size);int len = strlen(str);if (len + _size > _capacity){reserve(len + _size);}int end = len + _size;// 这个只是挪动pos后面数据的过程！while (end > pos){_str[end] = _str[end - len];--end;}// 插入strncpy(_str + pos, str, len);_size = len+_size;}// 12.erase的模拟：void erase(size_t pos, size_t len = -1){assert(pos < _size);if (len == -1 || len >= _size - pos){_str[pos] = '\0';_size = pos;}else{strcpy(_str + pos, _str + pos + len);_size -= len;}}// 13.swap的模拟：void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}// 14.find的模拟// (1)查找字符！size_t find(char ch, size_t pos)const// pos的意义就是：从哪个位置开始查找！{assert(pos <= _size);for (size_t i = pos; i < _size; i++){if (_str[i] == ch) {return i;}else{return -1;}}}// (2)查找字符串！size_t find(char* str, size_t pos)const// pos的意义就是：从哪个位置开始查找！{assert(pos < _size);const char* p = strstr(_str + pos, str);if (p){return p-_str;}else{return -1;}}// 15.substr的模拟：(从字符串中截取一段长度len的子字符串！)string substr(size_t pos, size_t len = -1){string sub;// (1)截取的长度len远超于字符串的总长度_sizeif (len >= _size - pos){for (size_t i = pos; i < _size; i++){sub += _str[i];}}else{//for (size_t i = pos; i < _size - pos; i++)for (size_t i = pos; i < pos+len; i++)//应该打印的是len个长度的！{sub += _str[i];}}return sub;}// 16.清理void clear(){_size = 0;_str[_size] = '\0';} 17.拷贝构造函数 (1) 传统写法：(必须是深拷贝) s1(s2)//string(const string& s)//{//// 因为是深拷贝，所以要用new新开辟一块空间//_str = new char [s._capacity+1];//strcpy(_str, s._str);//_size = s._size;//_capacity = s._capacity;//}// // (2)现代写法：// s1(s2)string(const string& s){string tmp = s._str;// 直接调用构造函数，让构造函数来完成 空间的开辟 和 拷贝！//string tmp (s._str);swap(tmp);} 18.赋值= 重载 (1)传统写法： s1=s2//string& operator=(const string& s)//{//// 开多大的空间，要看你要把谁赋值给别人。这里就是s2!//char* tmp = new char[s._capacity];//strcpy(tmp,s._str);//delete[] s._str;//_str = tmp;//// 更新参数//_size = s._size;//_capacity = s._capacity;//return *this;//}// (2)现代写法：复用，拷贝构造(在写 赋值 的现代写法之前，你还要写一个拷贝构造函数的现代写法，因为他要复用)// s1=s2string& operator=(const string& s){string tmp(s);// 重载赋值函数调用拷贝构造，不会陷入死循环！只有拷贝构造自己调用拷贝构造才会陷入死循环！swap(tmp);return *this;}};// 1.重载 <<ostream& yjl::operator<<(ostream& out, const yjl::string& _str){for (size_t i = 0; i < _str.size(); i++){out << _str[i];}return out;}// 2.getline函数的模拟：istream& getline(istream& in, string& s){//1.先清理s.clear();char ch;// in>>chch = in.get();char buff[128];size_t i = 0;while (ch != '\n'){buff[i++] = ch;// buff[0,126]if (i == 127){buff[127] = '\0';s += buff;i = 0;}ch = in.get();}// 走到此处：遇到了'\n' && 没有进去if(i==127)没有把数组填充满！if (i > 0)// {buff[i] = '\0';s += buff;}return in;}void test_string1(){string s1 = "hello world";string s2;cout << s1 << endl;for (size_t i = 0; i < s1.size(); i++){cout << s1[i]++ << " ";}cout << endl;for (size_t i = 0; i < s1.size(); i++){cout << s1[i] << " ";}cout << endl;}void test_string2(){string s1 = "hello world";string::iterator it1 = s1.begin();while (it1 != s1.end()){cout << *it1 << " ";it1++;}cout << endl;// 范围forfor (auto e : s1){cout << e << " ";}cout << endl;}void test_string3(){string s1("hello world");s1.push_back('1');s1.push_back('2');s1.push_back('3');s1.push_back('4');cout << s1 << endl;//string s2("xxx");s1.append("xxx");cout << s1 << endl;s1 += "10,9,8,7";cout << s1 << endl;s1 += '6';cout << s1 << endl;}void test_string4(){string s1 = "hello world";s1.insert(0, 'x');cout << s1 << endl;s1.insert(4, "ccc");cout << s1 << endl;}void test_string5(){string s1 = "hello world";s1.erase(0, 5);cout << s1 << endl;}void test_string6(){string s1 = "hello world";string s2 = "hello bite";cout << s1 << endl;cout << s2 << endl;swap(s1, s2);cout << s1 << endl;cout << s2 << endl;}void test_string7(){string s1 = "hello world";size_t ret1=s1.find('o', 0);cout << ret1 << endl;//size_t ret2=s1.find("ld", 0);??????????????}void test_string8(){ 下面演示一下由于浅拷贝(值拷贝)出现的错误问题//string s;//string s1 = "hello world";//s = s1.substr(2, 5); // 这一步 = (赋值)是浅拷贝 s1调用substr函数后的返回值(包括地址)直接浅拷贝给了s 所以局部变量s的_str和substr的_str的地址是一样的，指向同一空间，在局部变量s析构的时候会与substr的_str冲突////cout << s << endl;//string s;string s1 = "hello world";string s = s1.substr(2, 5);cout << s << endl;}// 有疑问没解决！拷贝构造函数！！！void test_string9(){string s2 = "hello bite";string s1(s2);cout << s1 << endl;}void test_string10(){string s1 = "hello bite";string s2 = s1;cout << s2 << endl;}}

2.源文件：

#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h>#include <iostream>using namespace std;#include "string.h"int main(){//yjl::test_string2();//yjl::test_string1();//yjl::test_string3();//yjl::test_string4();//yjl::test_string5();//yjl::test_string6();//yjl::test_string7();//yjl::test_string8();yjl::test_string9();//yjl::test_string10();return 0;}

---

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！

本文链接：https://www.kjpai.cn/news/2024-04-10/156392.html，文章来源：网络cs，作者：晨起，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！