【C++】：string类底层的模拟实现

2024-06-04 1637阅读

目录

  • 引言
  • 1，构造函数
  • 2，析构函数
  • 3，取出字符串的地址
  • 4，计算有效数据个数
  • 5，[ ]运算符重载
  • 6，简单迭代器
  • 7，预开空间(扩容)
  • 8，尾插一个字符
  • 9，尾插一个字符串
  • 10，+=运算符重载
  • 11，在pos位置插入字符/字符串
    • 11.1 在pos位置插入字符
    • 11.2 尾插一个字符串
    • 12，从pos位置开始删除长度为len的字符串
    • 13，从pos位置开始查找字符/字符串
      • 13.1 查找字符
      • 13.2 查找字符串
      • 14，拷贝构造(传统)
      • 15，=赋值拷贝(传统)
      • 16，交换函数swap
      • 17，从pos位置开始取len个字符的串
      • 18. 字符串的比较
      • 19，清除函数clear
      • 20，流插入，流提取
        • 20.1 流插入
        • 20.2 流提取
        • 21，拷贝构造和赋值拷贝的现代写法(重点)
          • 21.1 拷贝构造
          • 21.2 赋值拷贝

            引言

            点击跳转到文章：【string类的基本使用】

            上一篇文章已经对string类进行了简单的介绍，大家只要能够正常使用即可。

            这篇文章主要是对string类的一些重点接口函数进行模拟实现。本文依然采用多文件的方式，string.h放类的声明，string.cpp放成员函数的定义。

            string.h

            #pragma once
#include 
#include 
#include 
using namespace std;
//定义一个叫做bit的命名空间，隔离C++库里的string类
 namespace bit
{
	 class string
	 {
	 public:
		 //typedef实现二次封装
		 //由于string类是连续的空间，所以可以定义为原生指针
		 typedef char* iterator;
		 //const迭代器，指针指向的内容不能修改
		 typedef const char* const_iterator;
		 //实现迭代器,一定要实现为begin 和end
		 //迭代器屏蔽了底层细节，提供了一种简单通用的访问容器的方式
		 iterator begin();
		 iterator end();
		 const_iterator begin()const;
		 const_iterator end()const;
		// string();//无参构造
		
	    //有参与无参构造用全缺省进行合并,在声明处给缺省值
		 string(const char* str = "");//传参构造
		 //析构函数
		 ~string();
		 //拷贝构造
		 string(const string& s);
		 //赋值运算重载(传统)
		 //string& operator=(const string& s);
		 //赋值运算重载(现代)
		 string& operator=(string tmp);
		 const char* c_str() const;
		 //用下标的方式遍历字符串
		 size_t size()const;
		 char& operator[](size_t pos);
		 const char& operator[](size_t pos)const;
		 //用于扩容，一般不缩容
		 void reserve(size_t n);
		 void push_back(char ch);//尾插一个字符
		 void append(const char* str);//尾插字符串
		 //用运算符重载实现尾插
		 string& operator+=(char ch);
		 string& operator+=(const char* str);
		 //在指定位置插入 字符或是字符串
		 void insert(size_t pos, char ch);
		 void insert(size_t pos, const char* str);
		 //在指定位置删除长度为len
		 void erase(size_t pos = 0, size_t len = npos);
		 //从pos位置开始找字符或是字符串
		 size_t find(char ch, size_t pos =0);
		 size_t find(const char* str, size_t pos = 0);
		 //交换函数
		 void swap(string& s);
		 //从pos位置找一个子串
		 string substr(size_t pos = 0, size_t len = npos);
		 //字符串的比较
		 bool operator(const string& s)const;
		 bool operator=(const string& s)const;
		 bool operator==(const string& s)const;
		 bool operator!=(const string& s)const;
		 //把当前数据清除，但是不清空间
		 void clear();
	 private:
	 	 //这里的缺省值时给现代写法的构造函数的
		 char* _str = nullptr;
		 size_t _size = 0;//有效数据个数,指向最后一个有效数据的下一个位置\0
		 size_t _capacity = 0;//容量
		 //特例：静态成员变量只有无符号整形才可以在声明时给缺省值
		 //const static size_t npos = -1;//ok
		 //const static double d = 2.2;//err
		 const static size_t npos;
	 };
	 //流插入，流提取 
	 //不适合写成成员函数，涉及第一个参数的位置问题
	 istream& operator>> (istream& is, string& str);
	 ostream& operator
    //_str = nullptr;//err 防止对空指针的解引用
    
	_str = new char[_size + 1];//多开一个是给\0的
	_capacity = _size;
	strcpy(_str, str);//把初始化内容拷贝进空间
}

	delete[] _str;//析构销毁资源
	_str = nullptr;//置空
	_size = _capacity = 0;//置0
}

	return _str;//返回字符串的首地址，用于打印数据
}

	return _size;
}

	assert(pos  

            8，尾插一个字符
             

            8.1 先判断容量是否足够，再插入。
            8.2 注意\0的处理。
             

            //尾插一个字符
void string::push_back(char ch)
{
	if (_size == _capacity)
	{
		//先计算容量，2倍增
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		//再扩容
		reserve(newcapacity);
	}
	_str[_size] = ch;//覆盖
            9，尾插一个字符串
            的位置
	_str[_size + 1] = '
            //尾插字符串
void string::append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}
	//strcat:从
            10，+=运算符重载
            的位置开始追加，最后自动补上
            string& string::operator+=(char ch)
{
	push_back(ch);
	return *this;
}
string& string::operator+=(const char* str)
{
	append(str);
	return *this;
}

            
	//strcat(_str, str);
	strcpy(_str + _size, str);
	_size += len;
}

            ';//补上
            11，在pos位置插入字符/字符串
            
	++_size;
}

             

            11.1 在pos位置插入字符
             

            9.1 先判断容量是否足够，再插入。
            9.2 插入字符串时strcat 和strcpy均可以实现。但是strcat的底层需要遍历找到\0再进行拼接，最后自动补上\0，效率不高；所以推荐使用strcpy。
             

            void string::insert(size_t pos, char ch)
{
	assert(pos 
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}
	size_t end = _size;
	while (end = pos)
	{
		_str[end + 1] = _str[end];
		--end;
	}
	_str[pos] = ch;
	++_size;
}

             

            //在指定位置插入 
void string::insert(size_t pos, char ch)
{
	assert(pos 
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}
	int end = _size;
	while (end = (int)pos)
	{
		_str[end + 1] = _str[end];
		--end;
	}
	_str[pos] = ch;
	++_size;
}

             

            它的功能也是用来尾插字符或是字符串的，而且它比push_back和append使用的更广泛。
             

            //在指定位置插入 
void string::insert(size_t pos, char ch)
{
	assert(pos 
		size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newcapacity);
	}
	size_t end = _size + 1;
	while (end  pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;
	++_size;
}

             

            11.2 尾插一个字符串
             

            void string::insert(size_t pos, const char* str)
{
	assert(pos  _capacity)
	{
		reserve(_size + len);
	}
	
	//方式1
	/*int end = _size;
	while (end >= (int)pos)
	{
		_str[end + len] = _str[end];
		end--;
	}*/
	
	//方式2
	size_t end = _size + len;
	while (end > pos+len-1)
	{
		_str[end] = _str[end - 1];
		end--;
	}
	memcpy(_str + pos, str, len);
	_size += len;
}

             

            错误示范：
            原因：当pos为0，即头插时，程序崩溃！因为end是无符号整形，减到0再减后会变成整形最大值(40多亿)，造成***循环。
             

            猜想解决方法：
            只把end的类型改为int，也不行。因为当一个操作符两边的操作数类型不一样时，会产生隐式类型转换，比如有符号与无符号，有符号会隐式转换成无符号类型。
             

            12，从pos位置开始删除长度为len的字符串
             

            解决方法1：
            把end的类型改为int，end指向最后一位有效位的下一位，把pos也强转为int类型。
             

            void string::erase(size_t pos, size_t len )
{
	assert(pos  = _size)
	{
		_str[pos] = '
            13，从pos位置开始查找字符/字符串
            ';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}
}

             

            解决方法2：
            让end指向\0的下一位。
             

            13.1 查找字符
             

            13.2 查找字符串
             

            遇到的问题与上面的相同。
             

            size_t string::find(const char* str, size_t pos)
{
	//strstr：str存在时返回所在位置的指针
	const char* p = strstr(_str + pos, str);
	
	return p - _str;
}

             

            14，拷贝构造(传统)
             

            注意：
            1.此处在声明中两个形参的缺省值，size_t pos = 0， size_t len = npos。
            npos是const类型的静态成员变量，npos = -1，表示无符号整形的最大值(40多亿)。
             

            2.声明和定义分离时，静态成员变量的初始化。当是const修饰的size_t类型的静态变量时，是可以在声明时给缺省值的！这是个特例！ 但是一般不这样，声明和定义分离时，只要在.cpp中初始化即可。
             

            //要用深拷贝进行拷贝构造
//s2(s1);把s1拷贝给s2,*this是s2,s是s1的别名
string::string(const string& s)
{
	//开一个和要拷贝的一样大小的空间
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str);//把数据拷贝进新空间
	_size = s._size;
	_capacity = s._capacity;
}

             

            15，=赋值拷贝(传统)
             

            //s1 = s3;//s1是*this,s是s3的别名
string& string::operator=(const string& s)
{
	//避免自己给自己赋值
	if (this != &s)
	{
	     //多开一个空间给
            16，交换函数swap
            
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp, s._str);
		delete[] _str;
		_str = tmp;
		_size = s._size;
		_capacity = s._capacity;
		return *this;
	}
}

             

            size_t string::find(char ch, size_t pos)
{
	for (size_t i = pos; i  

            //s1.swap(s3)
void string::swap(string& s)
{
	//调用库中的swap函数，交换内置类型
	//不直接交换数据，而是交换两块空间的指针
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}

             

            17，从pos位置开始取len个字符的串
             

            18. 字符串的比较
             

            当我们不显示实现深拷贝时，使用编译器默认的浅拷贝有两个危害：
            14.1 s1和s2指向同一块空间，出了作用域时调用两次析构函数，造成程序崩溃。
            14.2 修改一个，另外一个也会修改。
             
 
 

            开新空间，拷贝数据，释放原空间，改变指针指向。
             
 
 
 
 

            复用了前面的构造函数和+=运算符。
             

            string string::substr(size_t pos, size_t len)
{
	//len大于pos后面剩余的字符，有多少取多少
	if (len > _size - pos)
	{
		string sub(_str + pos);//直接构造子串返回
		return sub;
	}
	else
	{
		string sub;
		sub.reserve(len);
		for (size_t i = 0; i  
 

            只要实现>运算符(或
		return strcmp(_str, s._str)

相关阅读：

1、VPS PTR记录设置详解，一步步教你操作

2、车贷背后的秘密，使用***的风险真相揭秘

3、揭秘混播VPS，轻松上手的使用指南，让你欲罢不能！

4、Linux VPS一年使用指南，必备知识与独家优惠信息大揭秘

5、揭秘VPS用户画像，哪些群体在使用VPS？

    高速稳定云服务器25元起
    免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

    相关阅读

    目录[+]