(C++)string类的模拟实现

简介: (C++)string类的模拟实现

 愿所有美好如期而遇


前言

我们模拟实现string类不是为了去实现他,而是为了了解他内部成员函数的一些运行原理和时间复杂度,在将来我们使用时能够合理地去使用他们。

为了避免我们模拟实现的string类与全局上的string类冲突(string类也在std命名空间中),我们用自己的命名空间包起来。

namespace A
{
    class string
    {
        static void test()
        {
        }
    }    
}
int main()
{
    A::string::test();
}

接下来我们开始模拟实现string类。

私有的成员变量,我们设计无符号整型计算有效字符数量的_size,以及记录空间大小的_capacity,最后就是字符指针,我们将来开辟好一块空间后存放字符串,将由他来指向。

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

构造函数:

默认是空串,并且我们默认比有效字符多开一个字节的空间,之后进行拷贝。

string(const char* str = "")
{
  _size = _capacity = strlen(str);
  _str = new char[_capacity + 1];
  strcpy(_str, str);
}

拷贝构造函数:

我们模拟实现string类,一定会有空间的开辟,一但对象涉及到拷贝,就不能是浅拷贝,否则会出现一块空间两次释放,直接崩掉。

string(const string& str)
{
  _capacity = str._capacity;
  _size = str._size;
  _str = new char[_capacity + 1];
  strcpy(_str, str.c_str());
}

赋值运算符重载:

同拷贝构造,对象也是不能值拷贝,否则会出现一块空间释放两次。

 

string& operator=(const string& str)
{
  if (this != &str)
  {
    _capacity = str._capacity;
    _size = str._size;
    char* tmp = new char[_capacity + 1];
    strcpy(tmp, str.c_str());
    delete[] _str;
    _str = tmp;
  } 
    return *this;
}

析构函数:

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

将string转换为const char*,我们会在strlen等C的接口处使用,比如strlen(s.c_str()),因为strlen他的参数是const char*类型的。

 

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

四个迭代器

只有物理地址空间连续才可以像这样,如果是链表,我们不能这样做。

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;
}

尾插单个字符,_capacity和_size都是只考虑有效字符,我们在创建空间时默认开空间比_capacity大一。

void push_back(char ch)
{
  if (_size == _capacity)
  {
    _capacity = 0 ? 4 : _capacity * 2;
    char* tmp = new char[_capacity + 1];
    strcpy(tmp, _str);
    delete[] _str;
    _str = tmp;
  }
  _str[_size++] = ch;
  _str[_size] = '\0';
}

reserve函数,我们使用reserve重新开空间,也是只考虑有效字符。

我们实现的reserve不可以缩容。

void reserve(size_t n)
{
  if (n > _capacity)
  {
    char* tmp = _str;
    //比需求多开一个字节的空间
    _str = new char[n + 1];
    strcpy(_str, tmp);
        //别忘记_capacity
    _capacity = n;
    delete[] tmp;
  }
}

尾插字符串

void append(const char* str)
{
  size_t len = strlen(str);
  if (_size + len > _capacity)
  {
    reserve(_size + len);
  }
  strcpy(_str + _size, str);
  _size += len;
}

赋值运算符+=的重载

//三个版本的+=运算符重载
string& operator+=(const string& str)
{
  append(str.c_str());
  return *this;
}
string& operator+=(const char* str)
{
  append(str);
  return *this;
}
string& operator+=(char ch)
{
  push_back(ch);
  return *this;
}

成员函数swap

//不用进行深拷贝,直接交换地址和大小
void swap(string& s)
{
  std::swap(_size, s._size);
  std::swap(_capacity, s._capacity);
  std::swap(_str, s._str);
}

清空字符串函数

void clear()
{
  memset(_str, 0, _size);
}

返回有效字符数量 ,判断是否为空

size_t size()const
{
  return _size;
}
bool empty()const
{
  return _size == 0;
}

重载[]运算符,我们重载两个版本的,重载const版本是因为我们有时候只读,不写,所以需要这样的重载。

char& operator[](size_t index)
{
  return _str[index];
}
const char& operator[](size_t index)const
{
  return _str[index];
}

find函数,找到后返回下标。strstr找到后返回的是找到的字符串的首地址,否则返回空。

size_t find(char c, size_t pos) const
{
  for (size_t i = pos; i < _size; i++)
  {
    if (_str[i] == c)
    {
      return i;
    }
  }
  return npos;
}
//hello world
size_t find(const char* s, size_t pos = 0) const
{
  char* tmp = strstr(_str, s);
  if (tmp == nullptr)
  {
    return npos;
  }
  return tmp - _str;
}

insert函数,从pos位置插入单个字符,以及字符串

string& insert(size_t pos, char c)
{
  assert(pos <= _size);
  if (_size == _capacity)
  {
    _capacity = 0 ? 4 : _capacity * 2;
    char* tmp = new char[_capacity + 1];
    strcpy(tmp, _str);
    delete[] _str;
    _str = tmp;
  }
  int end = _size;
  while (end >= (int)pos)
  {
    _str[end + 1] = _str[end];
    end--;
  }
  _str[pos] = c;
  _size++;
  return *this;
}
//pos是下标
string& insert(size_t pos, const char* str)
{
  assert(pos <= _size);
  int len = strlen(str);
  if (len + pos > _capacity)
  {
    reserve(len + pos);
  }
  int end = _size;
  while (end >= (int)pos)
  {
    _str[end + len] = _str[end];
    end--;
  }
  strncpy(_str + pos, str, len);
  _size += len;
  return *this;
}

erase函数,删除从pos节点开始的len个字符

string& erase(size_t pos, size_t len)
{
  //如果pos == size就和没删除一样,相当于删\0
  assert(pos < _size);
  //从pos位置删除len个字符,也就是pos后的字符全部删掉
  //传的len值接近npos,pos+len可能溢出,也会有未知错误
  if (len == npos || pos + len >= _size)
  {
    _str[pos] = '\0';
    _size = pos;
  }
  else
  {
    strcpy(_str + pos, _str + pos + len);
    _size -= len;
  }
  return *this;
}

substr,截取从pos位置开始长度为len的字符串 ,在他返回时,就是对象的值拷贝,会有临时对象产生,临时对象就需要我们自己写的拷贝构造函数了。

string substr(size_t pos = 0, size_t len = npos)
{
  assert(pos < _size);
  int end;
  string str;
  //hello world 2 3
  if (len == npos || pos + len > _size)
  {
    end = _size;
  }
  else
  {
    end = pos + len;
  }
  //记得给str扩容
  str.reserve(end - pos);
  while (end > pos)
  {
    str += _str[pos++];
  }
  return str;
}


目录
相关文章
|
8月前
|
存储 安全 C语言
C++ String揭秘:写高效代码的关键
在C++编程中,字符串操作是不可避免的一部分。从简单的字符串拼接到复杂的文本处理,C++的string类为开发者提供了一种更高效、灵活且安全的方式来管理和操作字符串。本文将从基础操作入手,逐步揭开C++ string类的奥秘,帮助你深入理解其内部机制,并学会如何在实际开发中充分发挥其性能和优势。
|
8月前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
|
4月前
|
对象存储 C++ 容器
c++的string一键介绍
这篇文章旨在帮助读者回忆如何使用string,并提醒注意事项。它不是一篇详细的功能介绍,而是一篇润色文章。先展示重载函数,如果该函数一笔不可带过,就先展示英文原档(附带翻译),最后展示代码实现与举例可以直接去看英文文档,也可以看本篇文章,但是更建议去看英文原档。那么废话少说直接开始进行挨个介绍。
88 3
|
4月前
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
95 0
|
4月前
|
存储 编译器 C语言
关于string的‘\0‘与string,vector构造特点,反迭代器与迭代器类等的讨论
你真的了解string的'\0'么?你知道创建一个string a("abcddddddddddddddddddddddddd", 16);这样的string对象要创建多少个对象么?你知道string与vector进行扩容时进行了怎么的操作么?你知道怎么求Vector 最大 最小值 索引 位置么?
82 0
|
4月前
|
存储 编译器 程序员
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
173 0
|
6月前
|
编译器 C++ 容器
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
184 12
|
7月前
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
131 16
|
7月前
|
缓存 安全 Java
《从头开始学java,一天一个知识点》之:字符串处理:String类的核心API
🌱 **《字符串处理:String类的核心API》一分钟速通!** 本文快速介绍Java中String类的3个高频API:`substring`、`indexOf`和`split`,并通过代码示例展示其用法。重点提示:`substring`的结束索引不包含该位置,`split`支持正则表达式。进一步探讨了String不可变性的高效设计原理及企业级编码规范,如避免使用`new String()`、拼接时使用`StringBuilder`等。最后通过互动解密游戏帮助读者巩固知识。 (上一篇:《多维数组与常见操作》 | 下一篇预告:《输入与输出:Scanner与System类》)
154 11
|
8月前
|
编译器 C语言 C++
类和对象的简述(c++篇)
类和对象的简述(c++篇)