【C++ • STL】探究string的源码

这篇具有很好参考价值的文章主要介绍了【C++ • STL】探究string的源码。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


ヾ(๑╹◡╹)ノ" 人总要为过去的懒惰而付出代价ヾ(๑╹◡╹)ノ"
【C++ • STL】探究string的源码,C++,笔记,c++,开发语言


一、深浅拷贝

浅拷贝:也称位拷贝,编译器只是将对象中的值拷贝过来。如果对象中管理资源,最后就会导致多个对象共享同一份资源,当一个对象销毁时就会将该资源释放掉,而此时另一些对象不知道该资源已经被释放,以为还有效,所以当继续对资源进项操作时,就会发生发生了访问违规。
浅拷贝:(1)析构两次,造成程序崩溃(2)一个对象修改影响另外一个

如果一个类中涉及到资源的管理,其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。

编译器默认生成的拷贝构造,是浅拷贝,会是两个对象指向同一块空间,当程序结束的时候,那么两个对象都会进行销毁,那么一块空间就会进行多次释放,从而引起崩溃。

深拷贝:给每一个对象分配资源,保证多个对象之间不会因为共享资源而导致多次释放造成程序崩溃。

二、传统版写法的string类(简单)

#pragma once
#include <iostream>
using namespace std;
#include <assert.h>

namespace yyqx//为了与库里面的string进行区分
{
	//仅仅实现一个简单的string,仅仅考虑资源管理深浅拷贝问题
	class string
	{
	public:
		//构造函数
		string(const char* str)
			:_str(new char[strlen(str) + 1])//这里的+1,是为了'\0'开辟空间
		{
			strcpy(_str, str);//拷贝的时候'\0'也拷贝了
		}

		//拷贝构造(深拷贝)
		//s2(s1)
		string(const string& s)
			:_str(new char[strlen(s._str) + 1])
		{
			strcpy(_str, s._str);
		}

		//赋值,也会有深浅拷贝的问题
		string& operator=(const string& s)
		{
			if (this != &s)//避免自己给自己赋值,会导致值被释放,就会变成随机值
			{
				//delete[] _str;//首先进行释放
				//_str = new char[strlen(s._str) + 1];//C++的new是不需要检查是否开辟空间
				会抛异常
				//strcpy(_str, s._str);

				//为了避免开辟空间失败,而本来的空间也被我们释放,可以先开启空间,
				//进行拷贝,然后再释放
				char* tmp = new char[strlen(s._str) + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;
			}
			return *this;
		}


		//析构函数
		~string()
		{
			if (_str)
			{
				delete[] _str;
			}
		}
		
		//目的为了输出字符串
		const char* c_str() const
		{
			return _str;
		}//返回c格式的字符串

		//重载[]
		char& operator[](size_t pos)
		{
			assert(pos < strlen(_str));//注意这里的范围
			return _str[pos];
		}

		size_t size()
		{
			return strlen(_str);
		}
	private:
		char* _str;
	};
}

赋值运算符重载也会有深浅拷贝的问题。赋值,对象本身是有值的【拷贝的时候,如果空间小,就会不够,空间大,就会造成资源浪费】

三、string类的模拟实现

string的增删查改以及使用string【传统】
基本框架

#pragma once
#include <iostream>
using namespace std;
#include <assert.h>

namespace yyqx//为了与库里面的string进行区分
{
	class string
	{
	public:

构造函数+析构函数
写法1

//构造函数
		string(const char* str)
			:_size(strlen(str))
			,_capacity(_size)
		{
			_str = new char[strlen(str) + 1];//这里的+1,是为了'\0'开辟空间
			strcpy(_str, str);//拷贝的时候'\0'也拷贝了
		}

		string()//注意,这里不是给的空,而是给了一个空的字符串//标准库里的就是给了一个""
			:_size(0)
			,_capacity(0)
		{
			_str = new char[1];
			_str[0] = '\0';
		}
  • 构造函数:初始化列表,初始化的顺序并不是初始化列表的顺序,而是成员变量在类中的声明次序。
  • 构造函数:注意默认的构造函数【编译器自动生成、缺省、函数重载】,默认的构造函数这里选择写一个同名函数,注意这里并不是给一个空指针,而是给了一个空字符串。
    写法2:(最优写法)
		string(const char* str = "")//这里默认值不能给nullptr,strlen以及拷贝strcpy会崩溃
			:_size(strlen(str))
			,_capacity(_size)
		{
			_str = new char[strlen(str) + 1];//这里的+1,是为了'\0'开辟空间
			strcpy(_str, str);//拷贝的时候'\0'也拷贝了
		}
		
		//析构函数
		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;//好习惯
				_size = 0;
				_capacity = 0;
			}
		}
  • 缺省值这不能给nullptr,strlen以及拷贝strcpy时程序会崩溃
  • 注意初始化列表
  • strcpy注意,拷贝的时候’\0’也拷贝了
  • new开空间的时候,一定要多开一个给’\0’

拷贝构造+赋值重载函数+其他

		//拷贝构造(深拷贝)
		//s2(s1)
		string(const string& s)
			:_size(strlen(s._str))
			,_capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}

		//赋值,也会有深浅拷贝的问题
		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;
		}
		//目的为了输出字符串
		const char* c_str() const
		{
			return _str;
		}//返回c格式的字符串
		
		char& operator[](size_t pos)//这里仅仅可以传入对象,不能传入const对象,如果是const对象,就会报错
		{
			assert(pos < _size);//注意这里的范围
			return _str[pos];
		}
		const char& operator[](size_t pos) const//这里就可以传入const对象
		{
			assert(pos < _size);
			return _str[pos];
		}

		//这里的const修饰的是this指针指向的对象const string s;
		size_t size() const//写const,普通对象以及const对象都可以调用,如果不加const对象就不可以调用
		{
			return _size;
		}
		size_t capacity() const//写const,普通对象以及const对象都可以调用
		{
			return _capacity;
		}

添加

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

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

		void reverse(size_t n)//一个扩容的作用
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;//注意这里的释放不是free
				_str = tmp;
				_capacity = n;
			}
		}

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

		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				reverse(_capacity == 0 ? 4 : _capacity * 2);//如果是一个空字符串,就会导致并没有扩容,
				//扩容要注意刚开始没有容量的情况下
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';//注意\0,容易遗漏
		}

		//append插入的字符个数是未知的,扩容二倍也不一定足够
		void append(const char* str)
		{
			size_t len = _size + strlen(str);
			if (len > _capacity)
			{
				reverse(len);
			}
			strcpy(_str + _size, str);
			_size = len;
		}//但是我们一般用+=
  • 判断容量是否满,如果 _size= _ capacity,容量扩2倍,new一个新容量的空间,释放旧空间,最后指针指向新的空间。
  • append (append插入的字符个数是未知的,扩容二倍也不一定足够:解决办法:reverse预留空间【一个扩容的作用】)
  • reverse 为string预留空间,避免多次扩容(提高效率)
  • resize用处:扩空间+初始化;删除数据保留前n个
    插入
string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);//这里的=_size相当于尾插
			//注意,这里容易忘记,size_t就已经大于等于0了,所以在这里我们主要保证pos是小于_size即可
			if (_size == _capacity)
			{
				reverse(_capacity == 0 ? 4 : 2 * _capacity);
			}
			//不可以用strcpy,这里不可以是同一块地址,对导致内容不是我们想要的
			//最后一个未知的字符移到_size然后就是倒数第二位移动,从后向前移动
			size_t end = _size + 1;
			//注意这里如果end=_size,当头插的时候,进入循环end会变成-1,因为是size_t所以又会进入循环,导致错误
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = ch;
			_size++;
			return *this;
		}

		//插入\0,用c_str(遇到\0停止打印)打印显示在屏幕的字符串长度会减小或者不变,但是_size会变大
		//用范围for或者迭代器可以打印出来

		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reverse(_size + len);
			}
			size_t end = _size + len;
			while (end > pos + len - 1)//这里注意
			{
				_str[end] = _str[end - len];
				--end;
			}
			strncpy(_str + pos, str, len);//防止为了遇见\0就不拷贝了(strcpy遇见\0就不拷贝了)
			_size += len;
			return *this;
		}

插入字符:

  • 不可以用strcpy,在字符进行向后移的时候,不可以是同一块地址,对导致内容不是我们想要的,最后一个未知的字符移到_size然后就是倒数第二位移动,从后向前移动
  • end=_size,当头插的时候,进入循环end会变成-1,因为是size_t,又是大于0所以又会进入循环,导致代码错误

插入字符串:

  • 防止为了遇见\0就不拷贝了,所以用的是strncpy(strcpy遇见\0就不拷贝了)

删除

//删除
		string& erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			//删除的数据大于等于_size
			if (len == npos || pos + len >= npos)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t begin = pos + len;
				while (begin <= _size)
				{
					_str[begin - len] = _str[begin];
					++begin;
				}
				_size -= len;
			}
			return *this;
		}

注意:npos类中静态成员的初始化,必须在类外,类和对象(下)本篇文章中有详细说明。【const在定义的时候必须初始化,但是静态成员的变量初始化又在外面】

查找

		size_t find(char ch, size_t pos = 0)
		{
			for (; pos < _size; ++pos)
			{
				if (_str[pos] == ch)
				{
					return pos;
				}
			}
			return npos;
		}

		size_t find(const char* str, size_t pos = 0)
		{
			const char* p = strstr(_str + pos, str);
			if (p == nullptr)
			{
				return npos;
			}
			else
			{
				return p - _str;
			}
			
		}
		
		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}
	private:
		char* _str;
		size_t _size;//有效字符的个数
		size_t _capacity;//存储有效字符的空间大小
		const static size_t npos;//正确的写法是在类外进行初始化
		//const static size_t npos = -1;//这种写法也可以,但是违背了正确的写法,要注意
	};
	const size_t string::npos = -1;
  • strstr返回的是指针,没有找到返回空指针。

流插入和流提取

/流插入和流提取
	//在类外
	//不可以用c_str(),因为遇见\0会停止
	//'\0'是不可以见字符,不会显示

	//流插入
	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}
		return out;
	}
	//流提取,字符从面板提取到s
	istream& operator>>(istream& in, string& s)
	{
			s.clear();
		//要把对象里面的字符清理掉,否则当对象不是空的时候,会导致字符直接加到已有对象的后面。
		//但是我们想要的是,对象是我们输入的字符串
	
		//第一种思路(缺点:频繁的+=,字符串过大,会导致频发的扩容,影响效率)
		/*char ch;
		ch = in.get();
		if (ch != ' ' && ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in*/

		//第二种思路(这种思路比较优,无论大小都可以避免频繁扩容)
		char ch;
		ch = in.get();
		char buff[128] = { '\0' };
		size_t i = 0;
		if (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				s += buff;
				memset(buff, '\0', 128);
				i = 0;
			}
			ch = in.get();
		}
		s += buff;
		return in;
	}
  • '\0’是不可以见字符,不会显示
  • clear()要把对象里面的字符清理掉,否则当对象不是空的时候,会导致字符直接加到已有对象的后面。但是我们想要的是,对象是我们输入的字符串

运算符重载

	//运算符重载
	//比较大小
	//全局函数.可以类比日期类
	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()) == 0;
	}

	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 || s1 == s2;
	}

	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}
}//这个是yyqx的大括号

这里是在全局变量,没有在类里面,是在类外

迭代器
string类private里面:

public:
		//迭代器
		typedef char* iterator;
		typedef const char* const_iterator;

		const_iterator begin() const
		{
			return _str;
		}

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

		iterator end() 
		{
			return _str + _size;
		}

四、现代版写法的string类

拷贝构造和赋值的现代写法

		//拷贝构造(深拷贝)
		//s2(s1)//现代写法,剥削行为,要完成深拷贝,
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		string(const string& s)
			:_str(nullptr)
			,_size(0)
			,_capacity(0)//这里要进行初始化,否则交换后,局部变量的销毁(随机值销毁,不可以)
		{
			//构造一个对象tmp,tmp里所有的东西this想要。this和tmp
			string tmp(s._str);//局部变量,出了作用域会销毁
			swap(tmp);
			//tmp出了作用域会销毁
		}

		//赋值,也会有深浅拷贝的问题
		//现代写法
		//第一种
		//string& operator=(const string& s)
		//{
		//	if (this != &s)//避免自己给自己赋值,会导致值被释放,就会变成随机值
		//	{
		//		string tmp(s._str);
		//		swap(tmp);//把tmp给this,出了作用域把this给tmp的值进行销毁
		//	}
		//	return *this;
		//}

		//第二种
		string& operator=(string s)//传值传参,拷贝构造,拷贝的值给this,并不会导致s的实参发生变化
		{
			swap(s);
			return *this;
		}
		//掌握现代写法

补充知识点
遍历方式中有一个是范围for(范围for的底层实现是迭代器,如果没有迭代器的程序,代码会进行报错)

代码展示:

	yyqx::string s("hello 12345");
	for (auto ch : s)
	{
		cout << ch << " ";
	}
	cout << endl;

在c语言中,我们用atoi。
【C++ • STL】探究string的源码,C++,笔记,c++,开发语言
string中的两个常用函数


五、总结

以上就是今天要讲的内容,本文详细的介绍了浅拷贝、浅拷贝和string的模拟实现。本文以及一文带你走进string详细的介绍了string的相关知识,希望给友友们带来帮助!文章来源地址https://www.toymoban.com/news/detail-712951.html

到了这里,关于【C++ • STL】探究string的源码的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 深入探究C++中的仿函数和迭代器——提升你的STL技能

    📖作者介绍:22级树莓人(计算机专业),热爱编程<目前在c++阶段——目标Windows,MySQL,Qt,数据结构与算法,Linux,多线程,会持续分享学习成果和小项目的 📖作者主页:热爱编程的小K 📖专栏链接:c++ 🎉欢迎各位→点赞👏 + 收藏💞 + 留言🔔​ 💬总结:希望你看

    2023年04月24日
    浏览(57)
  • C++ [STL之string模拟实现]

    本文已收录至《C++语言》专栏! 作者:ARMCSKGT 前面我们介绍了STL容器string的部分接口使用,有了string使我们对字符串的操作如鱼得水,其实string不止于使用方便,其实现也有许多我们值得学习的地方,本节将为您介绍string常用接口的代码实现! 本文接口的实现借助于C++官方

    2024年02月05日
    浏览(48)
  • 【C++精华铺】9.STL string

    目录 1. string类的优势 2. string类的常用接口 2.1 常用构造 1. 空串构造:string(); 2. C串构造:string(const char* s); 3. 拷贝构造:string(const string str); 4. 字符填充构造:string(size_t n, char c); 5. 迭代器构造:string(InputIterator first, InputIterator last); 2.2  string容量操作 1. size_t size(),size_t length

    2024年02月11日
    浏览(35)
  • 【C++】STL——string(两万字详解)

    🎇C++学习历程:STL——string学习 博客主页: 一起去看日落吗 持续分享博主的C++学习历程 博主的能力有限,出现错误希望大家不吝赐教 分享给大家一句我很喜欢的话: 也许你现在做的事情,暂时看不到成果,但不要忘记,树🌿成长之前也要扎根,也要在漫长的时光🌞中沉

    2024年01月25日
    浏览(43)
  • C++ STL string类模拟实现

    目录 string类成员变量 一.构造函数 二.析构函数 三.拷贝构造 四.size(),capacity() 五.operator [ ] 六. operator =  七.字符串比较  八.reserve() 九.push_back(),append() 十.operator+=  十一.insert()  十二.迭代器  十二.erase() 十三.swap()  十四.find() 十五.流提取,流输出 十六

    2024年02月14日
    浏览(51)
  • C++STL详解 string【C++】

    函数模板是一个蓝图,它本身并不是函数,是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器 在编译器编译阶段,对于模板函数的使用,编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比

    2024年02月08日
    浏览(54)
  • 【C++】STL之string类(1)

    个人主页:平行线也会相交💪 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 平行线也会相交 原创 收录于专栏【C++之路】💌 本专栏旨在记录C++的学习路线,望对大家有所帮助🙇‍ 希望我们一起努力、成长,共同进步。🍓 接下来就开始STL部分的学习了,本文先来学习一下

    2024年02月11日
    浏览(37)
  • C++ [STL之string的使用]

    本文已收录至《C++语言》专栏! 作者:ARMCSKGT 字符串在程序中经常出现,C语言为此提供了很多字符串操作函数,但是这些库函数与字符串是分离开的,不太符合OOP的思想,而且底层空间需要用户自己管理,稍不留神可能还会越界访问,于是STL单独为字符串实现了一个容器,

    2024年02月01日
    浏览(32)
  • 【C++】STL之string类(2)

    个人主页:平行线也会相交💪 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 平行线也会相交 原创 收录于专栏【C++之路】💌 本专栏旨在记录C++的学习路线,望对大家有所帮助🙇‍ 希望我们一起努力、成长,共同进步。🍓 reverse :在不改变字符串内容的前提下,预留一定的

    2024年02月12日
    浏览(36)
  • 【C++入门到精通】C++入门 —— string类(STL)

    目录 一、STL简介  1.STL是什么 2.STL的内容  3.STL的使用前提 二、string类 1.string类 是什么 2.string类的特点和操做 ⭕构造和初始化 ⭕字符串大小和容量 ⭕字符访问和修改 ⭕字符串连接和拼接 ⭕子串操作 ⭕字符串比较 ⭕字符串修改 ⭕获取字符的ASCII码 ⭕字符串大小写转换:

    2024年02月14日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包