AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【c++】string模拟实现(2)

2024-06-26 21
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【c++】string模拟实现(2)

运算符重载比较函数

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());
  }
  bool operator<(const string& s1, const string& s2)
  {
    return  !(s1 > s2 && s1 == s2);
  }
  bool operator<=(const string& s1, const string& s2)
  {
    return  !(s1 > s2);
  }
  bool operator>=(const string& s1, const string& s2)
  {
    return  !(s1 < s2);
  }
  bool operator!=(const string& s1, const string& s2)
  {
    return  !(s1 == s2);
  }

注意这里为什么要搞成全局的呢？？

void test10()
  {
    string str1;
    string str2;
    str1 += "abc";
    str2 += "aba";
    cout << (str1 == str2) << endl;
    cout << ("aba" == str2) << endl;//2
    cout << (str2== "aba") << endl;
  }

因为第二种的话不满足类成员做左操作数，全局的话就可以，而第三个是会搞一个类型转换.

void test10()
  {
    string str1;
    string str2;
    str1 += "abc";
    str2 += "aba";
    cout << (str1 == str2) << endl;
    cout << ("aba" == str2) << endl;
    cout << (str2== "aba") << endl;
     cout << (str1>str2) << endl;
     cout << (str1 >=str2) << endl;
     cout << (str1<str2) << endl;
     cout << (str1 <=str2) << endl;
     cout << (str1!=str2) << endl;
  }

运算符重载流插入

ostream& operator<<(ostream& out, const string& s)
  {
    for (auto e : s)//遍历一个一个输出
    {
      out << e;
    }
    return out;
  }

有返回值是为了可以连续流插入

运算符重载流提取

版本一：

istream& operator>>(istream& in, string& s)
  {
    
    char ch;
    
    in >> ch;//读取字符到ch
    while (ch != ' ' && ch != '\n')//读到‘ ’或‘\n’结束输入
    {s += ch;//将ch加进去
      in >> ch;//循环读取
    }
    
return in;
  }

这样写会有一个问题，就是cin和scanf一样默认‘\n’和‘ ’是分割符不会进行读取，所以ch不会是空格或换行，所以陷入死循环.

版本2：

c语言中可以用getchar来读取，而c++中存在get就可以读空格

istream& operator>>(istream& in, string& s)
  {
    
    char ch;
    
    in.get(ch);
    
    
    while (ch != ' ' && ch != '\n')
    {
    
    
      s += ch;
      in.get(ch);
    }
    
      
      
    
    return in;
  }
void test11()
  {
    string str1;
    string str2;
    cin >> str1;//>>str2;//>>str2;
    cout << str1;
    //cout << str1.capacity();
  }

版本3

由于我们在s+=ch，会出现频繁扩容，影响效率，我们应该怎么解决呢？？

我们可以提前开好空间，但是不知道应该开多大.假如说我们开128个

istream& operator>>(istream& in, string& s)
  {
    
    char ch;
    
    in.get(ch);
    
    s.reserve(128);
    while (ch != ' ' && ch != '\n')
    {
    
    
      s += ch;
      in.get(ch);
    }
    
      
      
    
    return in;
  }
void test11()
  {
    string str1;
    string str2;
    cin >> str1;//>>str2;//>>str2;
    //cout << str1;
    cout << str1.capacity();
  }

两个数据开128就会有极大的浪费，多一点还好

版本4

istream& operator>>(istream& in, string& s)
  {
    s.clear();//可能我们s里面之前有数据，但是流提取是要覆盖的
    char ch;
    ch = in.get();
    
    char buff[128];
    int 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] = '\0';
      s += buff;
    }
    return in;
  }

这里感觉可以类比冯诺依曼体系，buff就相当于内存，先将输入的值放在内存buff里面，等到装满了，在一次性给s,减少搬运次数.避免了一次空间开的很大，而数据只有几个

clear

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

c_str

将const string* 转化为const char*

const char* c_str() const
    {
      return _str;
    }

cout不能直接处理自定义类型string,但是可以使用c_str将string转成常量字符串，内置类型就可以直接打印

源码

.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
#include<assert.h>
#include<iostream>
#include<algorithm>
namespace zjw
{
  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()
    {
      delete[]_str;
      _str = nullptr;
      _size = _capacity = 0;
    }
    size_t size()
    {
      return _size;
    }
    size_t capacity()
    {
      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];
    }
    void reserve(size_t n)
    {
      if (n > _capacity)
      {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[]_str;
        _str = tmp;
        _capacity = n;
      }
    }
    void push_back(char ch)
    {
      if (_capacity == _size)
      {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
      }
      _str[_size] = ch;
      _size++;
      _str[_size] = '\0';
    }
    void append(const char* str)
    {
      size_t len = strlen(str);
      if (_size + len > _capacity)
      {
        reserve(_size + len);
      }
      strcpy(_str + _size, str);
      _size += len;
      //_str[_size] = '\0';
    }
    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);
      if (_capacity == _size)
      {
        reserve(_capacity == 0 ? 4 : _capacity * 2);
      }
      size_t end = _size + 1;
      while (end > pos)
      {
        _str[end] = _str[end - 1];
        end--;
      }
      _str[pos] = ch;
      _size++;
    }
    const char* c_str() const
    {
      return _str;
    }
    void earse(size_t pos, size_t len = npos)
    {
      assert(pos < _size);
      if (len == npos || pos > _size - len)
      {
        _str[pos] = '\0';
        _size = pos;
      }
      else
      {
        strcpy(_str + pos, _str + pos + len);
        _size -= len;
      }
    }
    bool empty()
    {
      return _size == 0;
    }
    void resize(size_t n, char ch = '\0')
    {
      if (n <= _size)
      {
        _str[n] = '\0';
        _size = n;
      }
      else
      {
        reserve(n);
        for (size_t i = _size; i < n; i++)
        {
          _str[i] = ch;
        }
        _size = n;
      }
    }
    void insert(size_t pos, const char* str)
    {
      size_t len = strlen(str);
      if (_size + len > _capacity)
      {
        reserve(_size + len);
      }
      size_t end = _size + len;
      while (end > pos + len - 1)
      {
        _str[end] = _str[end - len];
        end--;
      }
      strncpy(_str + pos, str, len);
      _size += len;
    }
    size_t find(char ch, size_t pos = 0)
    {
      for (int i = pos; i < _size; i++)
      {
        if (_str[i] == ch)
          return i;
      }
      return npos;
    }
    size_t find(const char* sub, size_t pos = 0) const
    {
      assert(pos < _size);
      const char* ptr = strstr(_str + pos, sub);
      if (ptr != nullptr)
      {
        return ptr - _str;
      }
      else
      {
        return npos;
      }
    }
    string substr(size_t pos = 0, size_t len = npos) const
    {
      string substr;
      if (pos > _size - len)
      {
        for (int i = pos; i <= _size; i++)
        {
          substr += _str[i];
        }
      }
      else
      {
        for (int i = pos; i < pos + len; i++)
        {
          substr += _str[i];
        }
        substr += '\0';
      }
      return substr;
    }
    void swap(string& str)
    {
      std::swap(_str, str._str);
      std::swap(_size, str._size);
      std::swap(_capacity, str._capacity);
    }
    string(const string& s)
    {
      string tmp(s._str);
      swap(tmp);
    
    
    
    
    }
    string& operator=(string tmp)
    {
      swap(tmp);
      return *this;
    }
    string& operator=(const string& 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 clear()
    {
      _size = 0;
      _str[0] = '\0';
    }
    friend istream& operator>>(istream& in, string& s);
  public:
    static const int  npos;
  private:
    char* _str;
    int _size;
    int _capacity;
  };
  const int string::npos = -1;
  void swap(string& x, string& y)
  {
    x.swap(y);
    cout << "没使用库里的" << endl;
  
  }
  istream& operator>>(istream& in, string& s)
  {
    s.clear();
    char ch;
    ch = in.get();
    
    char buff[128];
    int 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] = '\0';
      s += buff;
    }
    return in;
  }
  //istream& operator>>(istream& in, string& s)
  //{
  //  
  //  char ch;
  //  
  //  in.get(ch);
  //  
  //  s.reserve(128);
  //  while (ch != ' ' && ch != '\n')
  //  {
  //  
  //  
  //    s += ch;
  //    in.get(ch);
  //  }
  //  
  //    
  //    
  //  
  //  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());
  }
  bool operator<(const string& s1, const string& s2)
  {
    return  !(s1 > s2 && s1 == s2);
  }
  bool operator<=(const string& s1, const string& s2)
  {
    return  !(s1 > s2);
  }
  bool operator>=(const string& s1, const string& s2)
  {
    return  !(s1 < s2);
  }
  bool operator!=(const string& s1, const string& s2)
  {
    return  !(s1 == s2);
  }
  ostream& operator<<(ostream& out, const string& s)
  {
    for (auto e : s)
    {
      out << e;
    }
    return out;
  }
  //istream& operator>>(istream& in, string& s)
  //{
  //  s.clear();
  //  char ch;
  //  
  //  ch = in.get();
  //  //in >> ch;
  //  s.reserve(128);
  //  while (ch != ' ' && ch != '\n')
  //  {
  //    
  //    s += ch;
  //    ch = in.get();
  //    //in >> ch;
  //  }
  //  return in;
  //
  //
  //
  //
  //}
  void test1()
  {
    string str;
    str += 'a';
    str += 'b';
    str += "beijing";
    string::iterator it = str.begin();
    while (it != str.end())
    {
      cout << *it << " ";
      it++;
    }
  }
  void test2()
  {
    string str;
    str.push_back('a');
    str.push_back('a');
    str.push_back('b');
    str.push_back('a');
    str.push_back('a');
    string::iterator it = str.begin();
    while (it != str.end())
    {
      cout << *it << " ";
      it++;
    }
    cout << str[2];
  }
  void test3()
  {
    string str;
    str.append("stringbj");
    for (auto& e : str)
    {
      cout << e << " ";
    }
  }
  void print_string(const string it)
  {
    string::const_iterator res = it.begin();
    while (res != it.end())
    {
      cout << *res << " ";
      ++res;
    }
  }
  void test4()
  {
    string str;
    str += "abc";
    str.append("stringbj");
    string::iterator it = str.begin();
    while (it != str.end())
    {
      cout << *it << " ";
      it++;
    }
    //str.insert(0, 'g');
    for (auto& e : str)
    {
      cout << e << " ";
    }
    cout << endl;
    // str.earse(1,string::npos);*/
    /* for (auto e : str)
     {
       cout << e << " ";
     }*/
     // print_string(str);
  }
  void test5()
  {
    string str;
    str.push_back('a');
    str.push_back('a');
    str.push_back('b');
    str.resize(10);
    /* string::iterator it = str.begin();
     while (it != str.end())
     {
       cout << *it << " ";
       it++;
     }*/
    cout << str.c_str();
  }
  void test6()
  {
    string str;
    str.push_back('a');
    str.push_back('a');
    str.push_back('b');
    str.insert(2, "hello");
    cout << str.c_str();
  }
  void test7()
  {
    string str;
    str.push_back('a');
    str.push_back('a');
    str.push_back('b');
    str.insert(2, "hello");
    cout << endl;
    int ret = str.find('b', 0);
    cout << ret;
  }
  void test8()
  {
    string str;
    str += "beijing huanyingni zhangjiawang";
    int ret = str.find("zhangjiawang");
    cout << ret;
  }
  void test9()
  {
    string str;
    str += "beijing huanyingni zhangjiawang";
    string op = str.substr(0, 10);
    cout << op.c_str();
  }
  void test10()
  {
    string str1;
    string str2;
    str1 += "abc";
    str2 += "aba";
    cout << (str1 == str2) << endl;
    cout << ("aba" == str2) << endl;
    cout << (str2== "aba") << endl;
     cout << (str1>str2) << endl;
     cout << (str1 >=str2) << endl;
     cout << (str1<str2) << endl;
     cout << (str1 <=str2) << endl;
     cout << (str1!=str2) << endl;
  }
  void test11()
  {
    string str1;
    string str2;
    cin >> str1;//>>str2;//>>str2;
    //cout << str1;
    cout << str1.capacity();
  }
  void test12()
  {   string str1;
    string str2;
    str1 += "hello";
    str2+="nihao";
    cout << "str1:"<<str1 << endl;
    cout << "str2:"<<str2 << endl;
    str1.swap(str2);
    cout << "str1:" << str1 << endl;
    cout << "str2:" << str2 << endl;
  }
  void test13()
  {
    string str1;
    string str2;
    str1 += "hello";
    str2 += "nihao";
    cout << "str1:" << str1 << endl;
    cout << "str2:" << str2 << endl;
    swap(str1, str2);
    cout << "str1:" << str1 << endl;
    cout << "str2:" << str2 << endl;
  
  
  }
  void test14()
  {
    
    string str2;
    
    str2 += "nihao";
    string str1(str2);
  
  
  
  }
  
}

.cpp

#include"标头.h"
int main()
{
  zjw::test11();
}
文章标签：
云数据库 ClickHouse
C++
C语言
关键词：
C++ string
嘎嘎旺
目录
相关文章
睡觉待开机
|
1月前
|
安全 编译器 C语言
【C++数据结构】string的模拟实现
【C++数据结构】string的模拟实现
睡觉待开机
34 3
兰雪簪轩
|
1月前
|
编译器 C++ 容器
【C++】String常见函数用法
【C++】String常见函数用法
兰雪簪轩
16 1
可能只会写BUG
|
24天前
|
存储 C++
C++(五)String 字符串类
本文档详细介绍了C++中的`string`类，包括定义、初始化、字符串比较及数值与字符串之间的转换方法。`string`类简化了字符串处理，提供了丰富的功能如字符串查找、比较、拼接和替换等。文档通过示例代码展示了如何使用这些功能，并介绍了如何将数值转换为字符串以及反之亦然的方法。此外，还展示了如何使用`string`数组存储和遍历多个字符串。
可能只会写BUG
13 0
chian-ocean
|
1月前
|
安全 程序员 C++
C++ --＞ string类的使用（详细介绍）
C++ --＞ string类的使用（详细介绍）
chian-ocean
39 5
chian-ocean
|
1月前
|
存储 编译器 C语言
C++ --＞ string类模拟实现（附源码）
C++ --＞ string类模拟实现（附源码）
chian-ocean
60 4
Liuqz2009
|
1月前
|
存储 C++
C++ dll 传 string 类 问题
C++ dll 传 string 类 问题
Liuqz2009
20 0
qq2108462953
|
1月前
|
存储 C++
【C/C++学习笔记】string 类型的输入操作符和 getline 函数分别如何处理空白字符
【C/C++学习笔记】string 类型的输入操作符和 getline 函数分别如何处理空白字符
qq2108462953
31 0
是基德吖
|
2月前
|
C++
C++ string中的函数和常用用法
C++ 中string中的函数和常用用法
是基德吖
28 4
大柏怎么被偷了
|
1月前
|
编译器 C语言 C++
【C++】模拟实现string类
【C++】模拟实现string类
大柏怎么被偷了
14 0
大柏怎么被偷了
|
1月前
|
存储 算法 C语言
【C++】认识使用string类
【C++】认识使用string类
大柏怎么被偷了
15 0

热门文章

最新文章

  • 1
    C++模板初阶
  • 2
    c++打印乘法表
  • 3
    C/C++程序员上手C#应该知道的100件事（21~30）
  • 4
    教你如何使用 Visual Studio IDE 正确的进行 C++ 桌面开发
  • 5
    C++ Internals: STL之Map
  • 6
    Eclipse C/C++开发环境搭建
  • 7
    C++中的显式类型转化
  • 8
    Visual Studio Installer打包后生成的安装文件每次执行都需要重新安装C++ 2010运行库(x86)的解决方案
  • 9
    C++ STL算法系列4---unique , unique_copy函数
  • 10
    C++：多态之重载
  • 1
    C++ new和delete的用法
    69
  • 2
    为什么c++要引入class关键字
    55
  • 3
    【C++】使用g++指令控制【翻译】各个过程
    45
  • 4
    【C++】一文深入浅出带你参透库中的几种 [ 智能指针 ]及其背后实现原理（代码＆图示）
    54
  • 5
    【C++】C++中的【文件IO流】使用指南 [手把手代码演示] ＆ [小白秒懂]
    63
  • 6
    【C++】istream类型对象转换为逻辑条件判断值
    43
  • 7
    【C++】一文全解四种经典 [ 特殊类 ]的设计
    46
  • 8
    【C++】【C++的常变量取地址问题（对比C的不同）】const修饰的常变量＆volatile修饰用法详解（代码演示）
    39
  • 9
    【C++】C++中规范[ 类型转换标准 ] 的四种形式
    46
  • 10
    【C++小小知识点】重载、覆盖(重写)、隐藏(重定义)的对比【详解】（23）
    69

    • 相关课程

    更多
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce

    • 相关实验场景

    更多
  • 语言入门-3：string的方法
    • 下一篇
    使用OSS上传下载文件