【C++】手撕string思路梳理

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量821 收藏 10
点赞数 12
文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77649794/article/details/134857694
版权

目录

基本思路

代码实现

1.构建框架：

2.构建函数重载

3.迭代器：

4.遍历string

5.resetve 开空间，insert任意位置插入push_back,append,+=(按顺序依次实现)

6.erase删除，clear清除，resize缩容

7.流插入，流提取

全部代码

本文是对模拟string步骤进行梳理 若要详细讲解请跳转至：【C++】string模拟-CSDN博客

string讲解：【C++】String类-CSDN博客

基本思路

  1. 构建string类框架

    构造函数， 拷贝构造，析构，返回字符串的 C 风格表示，返回字符串长度，返回总容量

  2. 构建函数重载

    operator=,operator[]，> == >= < <= !=

  3. 迭代器：

    begin() && end()

  4. 遍历string

  5. resetve 开空间，insert任意位置插入，push_back,append,+=,交换

  6. erase删除，clear清除，resize缩容

  7. 流插入，流提取

代码实现

1.构建框架：

 
class string
 {
 private:
   char *_str;
   size_t _size;
   size_t _capacity;
 public:
   string(const char *str = "")
       : _size(strlen(str))
   {
       _capacity = _size = 0 ? 3 : _size;
       _str = new char[_size + 1];
       strcpy(_str, str);
   }
 ​
   // 拷贝
   string(const string &s)
       : _size(s._size), _capacity(s._capacity)
   {
       _str = new char[_capacity + 1];
       strcpy(_str, s._str);
   }
 ​
   ~string()
   {
       delete[] _str;
       _str = nullptr;
       _capacity = _size = 0;
   }
   
   const char *c_str()
   {
       return _str;
   }
   //?
   size_t size() const // const?
   {
       return _size;
   }
   size_t capacity() const
   {
       return _capacity;
   }
 };

2.构建函数重载

 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;
 }
 ​
 char &operator[](size_t pos)
 {
     assert(pos < _size);
     return _str[pos];
 }
 ​
 const char &operator[](size_t pos) const
 {
     assert(pos < _size);
     return _str[pos];
 }
 ​
 bool operator<(string &s) const
 {
     return strcmp(_str, s._str) < 0;
 }
 bool operator==(string &s) const
 {
     return strcmp(_str, s._str) == 0;
 }
 bool operator<=(string &s) const
 {
     return *this < s || *this == s;
 }
 bool operator>(string &s) const
 {
     return !(*this <= s);
 }
 bool operator>=(string &s) const
 {
     return !(*this < s);
 }
 bool operator!=(string &s) const
 {
     return !(*this == s);
 }

3.迭代器：

 typedef char *iterator;
 typedef const char *const_iterator;
 ​
 iterator begin()
 {
     return _str;
 }
 iterator end()
 {
     return _str + _size;
 }

4.遍历string

 void Print(const string &s)
 {
     //方法1
     for (size_t i = 0; i < s.size(); i++)
     {
         cout << s[i] << " ";
     }
     cout << endl;
     
     //方法二：迭代器遍历
     const_iterator rit = s.begin();
     while (rit != s.end())
     {
         cout << *rit << " ";
         ++rit;
     }
 }

5.resetve 开空间，insert任意位置插入push_back,append,+=(按顺序依次实现)

 void reserve(size_t n)
 {
     if (n > _capacity)
     {
         char *tmp = new char[n + 1];
         strcpy(tmp, _str);
         delete[] _str;
         _str = tmp;
         _capacity = n;
     }
 }
 ​
 string &insert(size_t pos, char ch)
 {
     assert(pos <= _size);
     // 判断大小
     if (_size + 1 > _capacity)
     {
         reserve(2 * _capacity);
     }
     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 - 1)
     {
         _str[end - len] = _str[end];
         --end;
     }
     strncpy(_str + pos, str, end);
     _size += len;
 ​
     return *this;
 }
 ​
 void push_back(char ch)
 {
     insert(_size, ch);
 }
 ​
 void append(const char *str)
 {
     insert(_size, str);
 }
 ​
 string &operator+=(char ch)
 {
     push_back(ch);
     return *this;
 }
 ​
 string &operator+=(const char *str)
 {
     append(str);
     return *this;
 }
交换：

 void swap(string &s)
 {
     std::swap(_str, s._str);
     std::swap(_capacity, s._capacity);
     std::swap(_size, s._size);
 }

6.erase删除，clear清除，resize缩容

 string &erase(size_t pos, size_t len = npos)
 {
     assert(pos < _size);
     if (len == npos || len >= _size)
     {
         _str[pos] = '\0';
         _size = pos;
     }
     else
     {
         strcpy(_str + pos, _str + pos + len);
         _size -= len;
     }
     return *this;
 }
 ​
 void resize(size_t n, char ch = '\0')
 {
     if (n < _size)
     {
         _size = n;
         _str[_size] = '\0';
     }
     else if (n > _size)
     {
         if (n > _capacity)
         {
             reserve(n);
         }
         size_t i = _size;
         while (i < n)
         {
             _str[i] = ch;
             ++i;
         }
         _size = n;
         _size = '\0';
     }
 }
 ​
 void clear()
 {
     _str[0] = '\0';
     _size = 0;
 }

7.流插入，流提取

 ostream &operator<<(ostream &out, const string &s)
 {
     for (size_t i = 0; i < s.size(); ++i)
     {
         out << s[i];
     }
     return out;
 }
 ​
 istream &operator>>(istream &in, string &s)
 {
     s.clear();
     char ch = in.get();
     char buff[128];
     size_t i = 0;
 ​
     while (ch != ' ' && ch != '\n')
     {
         buff[i++] = ch;
         if (i == 127)
         {
             buff[127] = '\0';
             s += buff;
             i = 0;
         }
         ch = in.get();
     }
 ​
     if (i != 0)
     {
         buff[i] = ch;
         buff[i + 1] = '\0';
         s += buff;
     }
     return in;
 }

全部代码

string.h

 #include <iostream>
 #include <assert.h>
 using namespace std;
 ​
 namespace wzf
 {
     class string
     {
     private:
         char *_str;
         size_t _size;
         size_t _capacity;
 ​
         static size_t npos;
 ​
     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 = 0 ? 3 : _size;
             _str = new char[_size + 1];
             strcpy(_str, str);
         }
 ​
         // 拷贝
         string(const string &s)
             : _size(s._size), _capacity(s._capacity)
         {
             _str = new char[_capacity + 1];
             strcpy(_str, s._str);
         }
 ​
         ~string()
         {
             delete[] _str;
             _str = nullptr;
             _capacity = _size = 0;
         }
 ​
         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;
         }
 ​
         char &operator[](size_t pos)
         {
             assert(pos < _size);
             return _str[pos];
         }
 ​
         const char &operator[](size_t pos) const
         {
             assert(pos < _size);
             return _str[pos];
         }
 ​
         bool operator<(string &s) const
         {
             return strcmp(_str, s._str) < 0;
         }
         bool operator==(string &s) const
         {
             return strcmp(_str, s._str) == 0;
         }
         bool operator<=(string &s) const
         {
             return *this < s || *this == s;
         }
         bool operator>(string &s) const
         {
             return !(*this <= s);
         }
         bool operator>=(string &s) const
         {
             return !(*this < s);
         }
         bool operator!=(string &s) const
         {
             return !(*this == s);
         }
 ​
         void reserve(size_t n)
         {
             if (n > _capacity)
             {
                 char *tmp = new char[n + 1];
                 strcpy(tmp, _str);
                 delete[] _str;
                 _str = tmp;
                 _capacity = n;
             }
         }
 ​
         string &insert(size_t pos, char ch)
         {
             assert(pos <= _size);
             // 判断大小
             if (_size + 1 > _capacity)
             {
                 reserve(2 * _capacity);
             }
             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 - 1)
             {
                 _str[end - len] = _str[end];
                 --end;
             }
             strncpy(_str + pos, str, end);
             _size += len;
 ​
             return *this;
         }
 ​
         void push_back(char ch)
         {
             insert(_size, ch);
         }
 ​
         void append(const char *str)
         {
             insert(_size, str);
         }
 ​
         string &operator+=(char ch)
         {
             push_back(ch);
             return *this;
         }
 ​
         string &operator+=(const char *str)
         {
             append(str);
             return *this;
         }
 ​
         string &erase(size_t pos, size_t len = npos)
         {
             assert(pos < _size);
             if (len == npos || len >= _size)
             {
                 _str[pos] = '\0';
                 _size = pos;
             }
             else
             {
                 strcpy(_str + pos, _str + pos + len);
                 _size -= len;
             }
             return *this;
         }
 ​
         void resize(size_t n, char ch = '\0')
         {
             if (n < _size)
             {
                 _size = n;
                 _str[_size] = '\0';
             }
             else if (n > _size)
             {
                 if (n > _capacity)
                 {
                     reserve(n);
                 }
                 size_t i = _size;
                 while (i < n)
                 {
                     _str[i] = ch;
                     ++i;
                 }
                 _size = n;
                 _size = '\0';
             }
         }
 ​
         void clear()
         {
             _str[0] = '\0';
             _size = 0;
         }
 ​
         const char *c_str()
         {
             return _str;
         }
         //?
         size_t size() const // const?
         {
             return _size;
         }
         size_t capacity() const
         {
             return _capacity;
         }
     };
     size_t string::npos = -1;
 ​
     ostream &operator<<(ostream &out, const string &s)
     {
         for (size_t i = 0; i < s.size(); ++i)
         {
             out << s[i];
         }
         return out;
     }
 ​
     istream &operator>>(istream &in, string &s)
     {
         s.clear();
         char ch = in.get();
         char buff[128];
         size_t i = 0;
 ​
         while (ch != ' ' && ch != '\n')
         {
             buff[i++] = ch;
             if (i == 127)
             {
                 buff[127] = '\0';
                 s += buff;
                 i = 0;
             }
             ch = in.get();
         }
 ​
         if (i != 0)
         {
             buff[i] = ch;
             buff[i + 1] = '\0';
             s += buff;
         }
         return in;
     }
 ​
     void TestString1()
     {
         string s1("Hello");
         cout << s1.c_str() << endl;
         string s2 = s1;
         string s3(s1);
         cout << s3.c_str() << endl;
         s1[0]++;
         cout << s1.c_str() << endl;
     }
     void TestString2()
     {
         string s1("Hello");
         cout << s1.c_str() << endl;
         string s2("NI");
         cout << (s1 > s2) << endl;
         cout << (s1 >= s2) << endl;
         cout << (s1 == s2) << endl;
         cout << (s1 != s2) << endl;
         cout << (s1 <= s2) << endl;
     }
     void TestString3()
     {
         string s1("Hello");
         cout << s1.c_str() << endl;
         s1 += '!';
         s1 += "2345";
         cout << s1.c_str() << endl;
     }
     void TestString4()
     {
         string s1("HelloWord");
         string s2("HelloWord");
         s1.erase(3, 1);
         cout << s1.c_str() << endl;
         s1.erase(3, 100);
         cout << s1.c_str() << endl;
         s2.resize(4);
         cout << s2.c_str() << endl;
         s2.resize(10, 'x');
         cout << s2.c_str() << endl;
     }
     void TestString5()
     {
         string s1("HelloWord");
         cout << s1 << endl;
         cin >> s1;
         string::iterator it = s1.begin();
         while (it != s1.end() - 1)
         {
             cout << *it << "";
             ++it;
         }
         cout << endl;
     }
 }

string.cpp

 #include "string.h"
 ​
 int main()
 {
     try // char* tmp = new char[s._capacity + 1];是否开辟异常
     {
         wzf::TestString5();
     }
     catch (const std::exception &e)
     {
         std::cerr << e.what() << '\n';
     }
 ​
     return 0;
 }

努力学c的楼下小王
关注
  • 12
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
【C++/嵌入式梳理】一、02.基本函数
Hi
04-28 816
( C语言标准库函数大全（ctype、time 、stdio、stdlib、math、string）_冬瓜~的博客-CSDN博客_c语言库函数C语言C++中assert的用法 - 知乎 (zhihu.com)函数原型 1、复制的内容不同（用途不同）。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。3、strcpy
C++ string格式化输出方式
08-25
今天小编就为大家分享一篇C++ string格式化输出方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
c++ String去除头尾空格的方法
09-04
主要介绍了c++ String去除头尾空格的方法,非常具有实用价值,需要的朋友可以参考下
C++中string的模拟实现
09-01
主要为大家详细介绍了C++中string的模拟实现，感兴趣的小伙伴们可以参考一下
C++中将string类型转化为int类型
08-31
本文主要介绍了C++中将string类型转化为int类型的方法。具有很好的参考价值，下面跟着小编一起来看下吧
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源的管理，而默认的拷贝构造函数或是赋值重载只能实现浅拷贝，因此在该类中应自己编写拷贝构造函数和赋值重载）、流插入操作符重载对于字符串中的空格输出的问题（不能直接以C语言中字符串的形式输出，而应逐个遍历字符输出）、流提取操作符重载中对于输入结束的处理（如果直接使用 cin >> ch 的形式输入字符，空格和换行符会被认为是字符输入间的间隔，不会进入缓冲区，如果要使空格也能被输入，并能以换行符作为结束标志，可以使用cin.get()的方式逐个输入字符；此外为了减少输入时不断开辟内存的消耗，可设置缓冲数组以实现数据的成块输入）；该资源有助于C++学习者从实现原理的层面进一步了解string类，为后续对string类灵活使用打下一个良好的基础；C++库中的string类接口较多，读者也可在此资源的基础上继续实现相关接口，并编写相应的测试代码进行测试。
c++ - 第26节 - c++知识梳理
qq_45113223的博客
01-20 1462
（1）需要熟练掌握这些容器的常见接口使用（增删查改：insert、erase、find、operator[]、iterator）（1）需要熟练掌握这些容器的常见接口使用（增删查改：insert、erase、find、operator[]、iterator）（1）需要熟练掌握这些容器的常见接口使用（增删查改：insert、erase、find、operator[]、iterator）1.重点熟练掌握的容器：vector、list、map、set、unoredered_map、unoredered_set。
手撕学生管理系统超详解——【c++】
m0_74755811的博客
06-17 1696
std::cout
c++ 常用面试题整理(不定时更新)
qq_28928005的博客
01-28 7274
面试中常见的C++面试题总结，快来看看，是否对你有帮助！
迷茫之后，拿下C++/Golang大厂实习offer
Jerry的编程之路
03-12 1295
这是我2021年的第14篇原创文章，原汁原味的技术之路尽在Jerrycodes这是一个同学今年斩获了几家大厂c++实习offer,并分享一下面试c++/golang后台方向的一些经验和面试...
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1006
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 803
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 294
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java多线程创建方式
weixin_57763462的博客
05-28 1076
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 510
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 1030
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1069
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
C++的string
11-12
C++的string是一个标准库中的类，用于处理字符串。它提供了许多方便的方法来操作字符串，例如插入、删除、查找、替换等。以下是一些常用的string方法： 1. 创建string对象 ```c++ string str1 = "hello"; // 直接赋值 string str2("world"); // 通过构造函数赋值 string str3(5, 'a'); // 通过构造函数赋值，生成5个'a' ``` 2. 访问string对象 ```c++ string str = "hello world"; char c = str[0]; // 通过下标访问 char c2 = str.at(1); // 通过at()方法访问 ``` 3. 修改string对象 ```c++ string str = "hello world"; str[0] = 'H'; // 通过下标修改 str.at(6) = 'W'; // 通过at()方法修改 str.append("!!!"); // 在末尾添加字符串 str.insert(6, "C++"); // 在指定位置插入字符串 str.replace(0, 5, "Hi"); // 替换指定位置的字符串 str.erase(3, 2); // 删除指定位置的字符 ``` 4. 查找string对象 ```c++ string str = "hello world"; int pos = str.find("world"); // 查找子串的位置 int pos2 = str.find_first_of("aeiou"); // 查找第一个元音字母的位置 int pos3 = str.find_last_of("aeiou"); // 查找最后一个元音字母的位置 ``` 5. string的大小和容量 ```c++ string str = "hello world"; int size = str.size(); // 返回字符串的大小 int capacity = str.capacity(); // 返回字符串的容量 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值