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

C++ --＞ string类模拟实现（附源码）

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

前言：

C++中STL扮演着极其重要的角色，学习C++重中之重的就是学习STL，虽然string不作为containers的其中一员，但是也是值得学习的le类。下面就进行string的模拟实现

string的模拟实现和顺序表是差不多，就是增加了C++的特性。

string 模拟实现

存储结构

结构上使用命名空间mystr进行封装，防止与库冲突，使用class封装成为对象string:

  • 定义 _size 方便记录string的大小。
  • 定义 _capacity方便记录string的容量大小
  • 定义 char* _str是存储数据，进行动态new出空间
  • nops：npos用于表示在字符串中未找到所查找的子串，或者表示一个超出字符串长度的有效索引位置。npos的值通常被定义为std::size_t类型的最大值，这是一个无符号整数类型，因此npos实际上是一个非常大的正整数，用于表示没有找到匹配项或字符串的结束位置.
namespace mystr
{
    class string
    {
        public:
        static const size_t npos = -1;
        private:    
        size_t _size;
        size_t _capacity;
        char* _str;
    };
}

默认构造函数

构造函数

  • 全缺省的构造函数也是默认构造函数，结尾给""常量字符串末尾存在\0;
  1. 默认构造函数：全缺省、无参、编译器默认生成的构造函数称之为默认构造函数
  • 采取初始化列表，对于常量引用可以进行初始化。strlen计算出大小，初始化_size
    2. 注意：初始化顺序就是声明的顺序，这个也是为什么将char* _str放在最后；
  • _capacoty初始化容量+1的目的是给\0开辟空间；
  • 最后将str进行拷贝，这里采用memcpy不采用strcpy
    3. memcpy可以将全部内容拷贝，strcpy会识别\0停止，假使字符串hello\0 world构造就不会得到我们想要的结果
string(const char* str = "")
    :_size(strlen(str))
        , _capacity(_size)
        , _str(new char[_capacity + 1])
    { 
        memcpy(_str, str, _capacity + 1);
    }

拷贝构造函数

  • 众所周知的是当不存在拷贝构造函数，编译器会自动生成拷贝构造函数；
  1. 编译器生成的仅仅会实现数值上的拷贝（浅拷贝）
  2. _strnew出空间，要实现内容上的拷贝（深拷贝）
  • _capacoty初始化容量+1的目的是给\0开辟空间；
string(const string& s)
{
    _capacity = s._capacity;
    _size = s._size;
    _str = new char[s._capacity+1];
    memcpy(_str, s._str, _capacity+1);
}

赋值运算符重载

赋值预算符重载的底层逻辑是和拷贝构造函数是一样的，在这里就不过多介绍了

string& operator=(const string& s)
{

    _capacity = s._capacity;
    _size = s._size;
    _str = new char[_capacity + 1];
    memcpy(_str, s._str, _capacity + 1);

}

析构函数

程序的整个历程开辟空间，不进行空间的释放不是一个好的习惯，这里析构函数就要上场了

~string()
{
    _size = 0;
    _capacity = 0;
    delete[] _str;
    _str = nullptr;
}

迭代器（iterator）

  • string的迭代器的本质就是指针，根据C语言的指针很容易就可以理解，就是将 char * 进行
    typefed char* iterator
  • 迭代器实现两个版本 const和非const， 只读和可读可写

begin（）

iterator begin()
{
    return _str;
}

iterator begin()const 
{
    return _str;
}

end（）

iterator end()
{
    return _str + _size;
}

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

容量（capacity）

size

  • mstr::string类定义了_size直接将其返回
size_t size()const
{
return _size;
}

capacity

  • mstr::string类定义了_capacity直接将其返回
size_t capacity() const
{
    return _capacity;
}

resize

  • resize是将后面指定大小初始化指定的字符（缺省：\0）
  • 进行容量的检查，不够扩容
  • 一层循环初始化为ch
  • 修改_size长度为n
void resize(size_t n,char ch = '\0')
{
    if (n < _size)
    {
        _str[n ] = '\0';
        _size = n;
    }
    else
    {
        reverse(n);

        for (size_t i = _size; i < n; i++)
        {
            _str[i] = ch;
        }

        _str[_size] = '\0';
        _size = n;
    }

}

reverse

  • 由于很多地方进行复用，需要在函数内部进行判断提高效率
  • 开辟一个大于原始空间的新的空间，将 _str拷贝过去，改变_str的指向，将新开辟的空间释放谨防内存泄漏
void reverse(size_t n)
{
    if (n > _capacity)
    {
        char* tmp = new char[n + 1];
        memcpy(tmp, _str, _capacity + 1);

        delete[] _str;
        _capacity = n;
        _str = tmp;
    }

}

empty

直接判断_size是否为0即可

bool empty()const
{
return _size == 0 ? true : false;
}

clear

  • 直接将首位置赋值为\0，修改_size大小即可
void clear()
{
    _str[0] = '\0';
    _size = 0;
}

修改（modify）

push_back

C++string中 push_back 函数声明：void push_back (char c);在字符串后追加一个字符；

  • 开始要检查容量 进行扩容这里用 reverse 实现
  • 由于一个字符，仅仅需要在_size位置上直接赋值，在_size+1的位置上赋值\0
 void push_back(char ch)
{
    if (_size == _capacity)
    {
        reverse(_capacity == 0 ? 4 : _capacity * 2);
    }

    _str[_size] = ch;
    _str[_size + 1] = '\0';
    _size++;
}


append

  • append后面追加一个字符可以进行复用 push_back
  • append后面追加一个字符串和添加一个string类是一样的思路是一样；
//追加一个字符
void append(const char ch)
{
push_back(ch);
}
//追加一个字符串
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reverse(_capacity + len);
}
memcpy(_str + _size, str, len + 1);
}
//追加一个string类
void append(const string& str)
{
if (_size + str._size == _capacity)
{
reverse(_size + str._size);
}

memcpy(_str + _size, str._str, str._size+1);
}

operator+=

由于是实现了append实现运算符重载就方便跟多，功能一样，结果一样直接进行复用

//追加一个字符
string& operator+= (const char* str)
{
    append(str);

    return *this;
}
//追加一个字符串
string& operator+= (const string& str)
{
    append(str._str);

    return *this;
}
//追加一个string类
string& operator+= (char ch)
{
    push_back(ch);
    return *this;
}

inset

  • 实现两个版本，插入字符和插入字符串
  • string类是没有实现push_front头插入，insert就有很大的作用了在pos位置进行插入
  • 首先进行pos位置的断言，保证pos在字符串的有效位置
  • 进行容量检查，进行扩容.
  • 将pos位置后面的字符（以及pos位置）依次向后面移len个长度，在pos位置插入字符（字符串）
  • i!= npos在for循环中如果i变成了0，之后再去减1 ，size_t下的-1会变为无线大，会陷入死循环。
  • 最后不要忘记将_size进行修改
//插入字符
string& insert(size_t pos, char c)
{
    assert(pos < _size);

    if (_capacity == _size)
    {
        reverse(_size+1);
    }

    for (size_t i = _size; i >= pos&& i!= npos; i--)
    {
        _str[i + 1] = _str[i];
    }
    _str[pos] = c;
    _size++;

    return *this;
}
//插入字符串
string& insert(size_t pos, const char* str)
{
    assert(pos < _size);
    size_t len = strlen(str);
    if (_capacity == _size)
    {     
        reverse(_size + len);
    }

    for (size_t i = _size; i >= pos&& i!= npos; i--)
    {
        _str[i + len] = _str[i];

    }
    memcpy(_str + pos, str, len);
    _size+=len;

    return *this;

}

erase

  • 首先进行pos位置的断言，保证pos在字符串的有效位置
  • erase是在pos位置删除len个字符（缺省值：npos）
  • 函数主体进入进len的判断，如果len == npos 或 pos + len >= _size超出字符串的长度，就是从pos后全部删除
  • 否则没有超过将pos + len位置后面的数据将 pos位置移动直至移动到\0
string& erase(size_t pos, size_t len = npos)
{
    assert(pos < _size);
    if (len == npos || pos + len >= _size)
    {
        _str[pos] = '\0';
        _size = pos;

    }
    else
    {
        size_t end = pos + len;

        while (end <= _size)
        {
            _str[pos++] = _str[end++];
        }

        _size -= len;
    }

}

swap

  • 利用C++库中的swap进行string类的交换
void swap(string& s)
{
string tmp(s);
std::swap(_str, tmp._str);
std::swap(_size, tmp._size);
std::swap(_capacity, tmp._capacity);
}

元素访问（Element access）

operator [ ]

  • 实现const和非const两种，只读和可读可改
  • 充分利用字符串特性可以进行下标的访问
//const
char& operator[](size_t index)
{
    assert(index < _size);

    return _str[index];
}
//nonconst
const char& operator[](size_t index)const
{
    assert(index < _size);

    return _str[index];
}

字符串操作（String operations）

c_str

  • 直接返回_str
const char* c_str()
{
    return _str;
}

find

  • 首先进行pos位置的断言，保证pos在字符串的有效位置
  • 字符串查找利用C语言中的strstr函数进行查找
  • 返回下面的下标，利用指针减指针的方法，没有找到返回npos
size_t find(const char* s, size_t pos = 0) const
{
    assert(pos < _size);
    char* p = strstr(_str, s);

    if (p)
    {
        return p - _str;
    }
    else
    {
        return npos;
    }

}

关系运算符(relational operators)

进行比较的重载

  • 实现< ==其他的进行复用即可
  • 使用memcpy进行比较，比较字符串较小的那个_size < s._size ?_size : s._size
  • 返回 为 0 返回比较长（_size < s._size）的那个否则返回假（ ret < 0）
//重载<
bool operator<(const string& s)
{
    int ret = memcmp(_str, s._str, (_size < s._size ?_size : s._size));

    return ret == 0 ? _size < s._size : ret < 0;
}
//重载==
bool operator==(const string& s)
{
    return _size == s._size && memcmp(_str, s._str, _size);
}
//重载<=
bool operator<=(const string& s)
{
    return !(*this > s);
}
//重载>
bool operator>(const string& s)
{
    return !(*this <= s);
}
//重载>=
bool operator>=(const string& s)
{
    return !(*this < s);
}
//重载!=
bool operator!=(const string& s)
{
    return !(*this == s);
}

流提取和插

operator<<

  • 这个函数是写在类外面的一个友元函数
  • 使用范围for进行实现
ostream& operator<<(ostream& out, const mystr::string& s)
{
  for (auto ch : s)
  {
    out << ch;
  }
  return out;
}

operator>>

  • s.clear();这句话是清理缓冲区上次cin的残留
  • 第一个while循环是处理缓冲区的空格
  • 创建一个数组，避免多次开辟空间，直至大小到128拷贝会加到string s 中
  • 最后的if语句是字符遇见空格或者换行结束，末尾添加\0
istream& operator>>(istream& in, string& s)
{
    s.clear();

    char ch = in.get();
    // 处理前缓冲区前面的空格或者换行
    while (ch == ' ' || ch == '\n')
    {
        ch = in.get();
    }
    char buff[128];
    int i = 0;

    while (ch != ' ' && ch != '\n')
    {
        buff[i++] = ch;
        if (i == 127)
        {
            buff[i] = '\0';
            s += buff;
            i = 0;
        }

        ch = in.get();
    }

    if (i != 0)
    {
        buff[i] = '\0';
        s += buff;
    }

    return in;
}

mystr:: string 源码

#pragma once

#include<iostream>

#include<string.h>
#include <assert.h>
#include <stdlib.h>

using namespace std;


namespace mystr
{
  class string
  {
    friend ostream& operator<<(ostream& _cout, const mystr::string& s);

    friend istream& operator>>(istream& _cin,mystr::string& s);
  public:
    typedef char* iterator;
    typedef const char* const_iterator;


    string(const char* str = "")
      :_size(strlen(str))
      , _capacity(_size)
      , _str(new char[_capacity + 1])
    { 
      memcpy(_str, str, _capacity + 1);
    }
    //析构函数
    ~string()
    {
      _size = 0;
      _capacity = 0;
      delete[] _str;
      _str = nullptr;
    }
    // 拷贝构造函数
    string(const string& s)
    {
      _capacity = s._capacity;
      _size = s._size;
      _str = new char[s._capacity+1];
      memcpy(_str, s._str, _capacity+1);
    }
    //赋值预算符重载
    string& operator=(const string& s)
    {

      _capacity = s._capacity;
      _size = s._size;
      _str = new char[_capacity + 1];
      memcpy(_str, s._str, _capacity + 1);

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

    //迭代器
    iterator begin()
    {
      return _str;
    }
    iterator end()
    {
      return _str + _size;
    }
    iterator begin()const 
    {
      return _str;
    }
    iterator end()const
    {
      return _str + _size;
    }
    
    //capacity

    size_t size()const
    {
      return _size;
    }
    size_t capacity() const
    {
      return _capacity;
    }

    void reverse(size_t n)
    {
      if (n > _capacity)
      {
        char* tmp = new char[n + 1];
        memcpy(tmp, _str, _capacity + 1);

        delete[] _str;
        _capacity = n;
        _str = tmp;
      }

    }
    void resize(size_t n,char ch = '\0')
    {
      if (n < _size)
      {
        _str[n ] = '\0';
        _size = n;
      }
      else
      {
        reverse(n);

        for (size_t i = _size; i < n; i++)
        {
          _str[i] = ch;
        }

        _str[_size] = '\0';
        _size = n;
      }

    }

    bool empty()const
    {
      return _size == 0 ? true : false;
    }
    
    //access

    //modify
    
    void push_back(char ch)
    {
      if (_size == _capacity)
      {
        reverse(_capacity == 0 ? 4 : _capacity * 2);
      }

      _str[_size] = ch;
      _str[_size + 1] = '\0';
      _size++;
    }

    void append(const char ch)
    {
      push_back(ch);
    }
    void append(const char* str)
    {
      size_t len = strlen(str);
      if (_size + len > _capacity)
      {
        reverse(_capacity + len);
      }
      memcpy(_str + _size, str, len + 1);
    }

    void append(const string& str)
    {
      if (_size + str._size == _capacity)
      {
        reverse(_size + str._size);
      }

      memcpy(_str + _size, str._str, str._size+1);
    }


    string& operator+= (const char* str)
    {
      append(str);

      return *this;
    }
    string& operator+= (const string& str)
    {
      append(str._str);

      return *this;
    }
    string& operator+= (char ch)
    {
      push_back(ch);
      return *this;
    }

    void clear()
    {
      _str[0] = '\0';
      _size = 0;
    }
    void swap(string& s)
    {
      string tmp(s);
      std::swap(_str, tmp._str);
      std::swap(_size, tmp._size);
      std::swap(_capacity, tmp._capacity);
    }
    //relational operators
    bool operator<(const string& s)
    {
      int ret = memcmp(_str, s._str, (_size < s._size ?_size : s._size));

      return ret == 0 ? _size < s._size : ret < 0;
    }

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

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


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

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

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

    // 返回c在string中第一次出现的位置

    size_t find(char c, size_t pos = 0) const
    {
      assert(pos < _size);

      for (size_t i = pos; i < _size; i++)
      {
        if (_str[i] == c)
        {
          return i;
        }
      }

      return npos;
    }


    // 返回子串s在string中第一次出现的位置

    size_t find(const char* s, size_t pos = 0) const
    {
      assert(pos < _size);
      char* p = strstr(_str, s);

      if (p)
      {
        return p - _str;
      }
      else
      {
        return npos;
      }
    
    }

    // 在pos位置上插入字符c/字符串str，并返回该字符的位置

    string& insert(size_t pos, char c)
    {
      assert(pos < _size);

      if (_capacity == _size)
      {
        reverse(_size+1);
      }

      for (size_t i = _size; i >= pos; i--)
      {
        _str[i + 1] = _str[i];
      }
      _str[pos] = c;
      _size++;
    
      return *this;
    }

    string& insert(size_t pos, const char* str)
    {
      assert(pos < _size);
      size_t len = strlen(str);
      if (_capacity == _size)
      {     
        reverse(_size + len);
      }

      for (size_t i = _size; i >= pos; i--)
      {
        _str[i + len] = _str[i];

      }
      memcpy(_str + pos, str, len);
      _size+=len;

      return *this;
    
    }

    string& erase(size_t pos, size_t len = npos)
    {
      assert(pos < _size);

      if (_capacity == _size)
      {
        reverse(_size + len);

      }
      if (len == npos || pos + len >= _size)
      {
        _str[pos] = '\0';
        _size = pos;

      }
      else
      {
        size_t end = pos + len;

        while (end <= _size)
        {
          _str[pos++] = _str[end++];
        }

        _size -= len;
      }
    
    }

  private:    
    size_t _size;

    size_t _capacity;
    char* _str;

    public:

    
    const static size_t npos;
  };

  const size_t string::npos = -1;
  
  ostream& operator<<(ostream& out, const mystr::string& s)
  {
    for (auto ch : s)
    {
      out << ch;
    }
    return out;
  }

  istream& operator>>(istream& in, string& s)
  {
    //清除缓冲区
    s.clear();

    char ch = in.get();

    while (ch == ' ' || ch == '\n')
    {
      ch = in.get();
    }

    char buff[128];
    int i = 0;

    while (ch != ' ' && ch != '\n')
    {
      buff[i++] = ch;
      if (i == 127)
      {
        buff[i] = '\0';
        s += buff;
        i = 0;
      }
      ch = in.get();
    }

    if (i!= 0)
    {
      buff[i] = '\0';
      s += buff;
    }

    return in;

  }

}

文章标签：
C++
编译器
C语言
存储
索引
关键词：
String类
C++ string类
C++ string
C++类
C++源码
chian-ocean
目录
相关文章
Dylaniou
|
5天前
|
Java
【编程基础知识】(讲解+示例实战)方法参数的传递机制(值传递及地址传递)以及String类的对象的不可变性
本文深入探讨了Java中方法参数的传递机制，包括值传递和引用传递的区别，以及String类对象的不可变性。通过详细讲解和示例代码，帮助读者理解参数传递的内部原理，并掌握在实际编程中正确处理参数传递的方法。关键词：Java, 方法参数传递, 值传递, 引用传递, String不可变性。
Dylaniou
17 1
【编程基础知识】(讲解+示例实战)方法参数的传递机制(值传递及地址传递)以及String类的对象的不可变性
喵手
|
2天前
|
安全 Java 测试技术
Java零基础-StringBuffer 类详解
【10月更文挑战第9天】Java零基础教学篇，手把手实践教学！
喵手
9 2
白子寰
|
5天前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
15 4
白子寰
|
5天前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
15 4
白子寰
|
5天前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
白子寰
10 1
Dylaniou
|
8天前
|
数据可视化 Java
让星星月亮告诉你，通过反射创建类的实例对象，并通过Unsafe theUnsafe来修改实例对象的私有的String类型的成员属性的值
本文介绍了如何使用 Unsafe 类通过反射机制修改对象的私有属性值。主要包括： 1. 获取 Unsafe 的 theUnsafe 属性：通过反射获取 Unsafe类的私有静态属性theUnsafe，并放开其访问权限，以便后续操作 2. 利用反射创建 User 类的实例对象：通过反射创建User类的实例对象，并定义预期值 3. 利用反射获取实例对象的name属性并修改：通过反射获取 User类实例对象的私有属性name，使用 Unsafe`的compareAndSwapObject方法直接在内存地址上修改属性值 核心代码展示了详细的步骤和逻辑，确保了对私有属性的修改不受 JVM 访问权限的限制
Dylaniou
25 4
白子寰
|
6天前
|
存储 编译器 C语言
【C++打怪之路Lv3】-- 类和对象（上）
【C++打怪之路Lv3】-- 类和对象（上）
白子寰
13 0
禁默
|
10天前
|
C语言 C++
深度剖析C++string(中）
深度剖析C++string(中）
禁默
32 0
六卿
|
1月前
|
Java 索引
java基础(13)String类
本文介绍了Java中String类的多种操作方法，包括字符串拼接、获取长度、去除空格、替换、截取、分割、比较和查找字符等。
六卿
34 0
java基础(13)String类
杀死一只知更鸟debug
|
29天前
|
安全 Java
String类-知识回顾①
这篇文章回顾了Java中String类的相关知识点，包括`==`操作符和`equals()`方法的区别、String类对象的不可变性及其好处、String常量池的概念，以及String对象的加法操作。文章通过代码示例详细解释了这些概念，并探讨了使用String常量池时的一些行为。
杀死一只知更鸟debug
26 3
String类-知识回顾①