STL库string模拟实现

最新推荐文章于 2024-09-02 13:43:09 发布
最新推荐文章于 2024-09-02 13:43:09 发布
阅读量572 收藏 12
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GDYJLXQ/article/details/134819041
版权

在C++中，string是一个类模板，定义在头文件<string>中，提供了对字符串的封装和操作。它实现了动态内存分配和复杂的字符串操作

下面是一些常用的string类成员函数：

  1. 构造函数：可以用于创建和初始化string对象，包括默认构造函数、用C字符串或另一个string对象初始化的构造函数等。

  2. 赋值操作符：可以将另一个string对象、C字符串或字符赋值给当前string对象，包括=、+=、append等操作符。

  3. 访问和修改字符：可以使用下标运算符[]、at()等访问单个字符，也可以使用insert()、erase()等函数插入、删除、替换字符。

  4. 获取字符串长度和容量：可以使用length()、size()获取字符串长度，capacity()获取字符串容量。

  5. 查找和比较字符串：可以使用find()、rfind()、substr()、compare()等函数查找和比较字符串。

  6. 字符串转换：可以使用stoi()、stod()等函数将字符串转换为数字或其他类型，也可以使用to_string()、to_wstring()等函数将数字或其他类型转换为字符串。

  7. 其他操作：还有很多其他的操作，如replace()、swap()、c_str()、empty()等。

需要注意的是，由于string类是动态内存分配的，因此在使用时需要注意内存管理和效率问题。一般来说，string类的效率比char数组和C字符串要低，但是可以使用一些技巧（如reserve()、resize()等）来提高效率。每一次string的复制、取值都由string类负责维护，不用担心复制越界和取值越界等问题。

可通过cplusplus获取更多用法

返回第一个和最后一个位置

iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

构造函数和拷贝构造

string(const char* str = "")//构造函数""里只有\0，\0不是有效字符不算容量空间
{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];//+1是最后一个位置存放\0，比如hello是占6个字节
		strcpy(_str, str);
}

string(const string& s)//拷贝构造 strting s2(s1)
			:_str(nullptr)
			,_size(0)
			,_capacity(0)
		{
			string tmp(s._str);
			this->swap(tmp);//this是默认的可不加
		}

析构函数

        ~string()//析构函数
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

返回容量和有效数据

        size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

返回C格式字符串

        const char* c_str()//返回C格式字符串
		{
			return _str;
		}

扩容函数和改变容量函数

         void reserve(size_t n)
		{
			if (n > _capacity)//原来的容量不够了
			{
				char* newstr = new char[n + 1];
				strcpy(newstr, _str);//把旧空间拷贝到新空间(\0)
				delete[] _str;//释放旧空间
				_str = newstr;
				_capacity = n;
			}
		}

		void resize(size_t n, char ch = '\0')//将size变成n,但capacity不变
		{
			if (n < _size)//这个实际上是截短字符（串）例：abcde->ab\0
			{
				_str[n] = '\0';
				_size = n;
			}

			else
			{
				if (n > _capacity)//扩容
				{
					reserve(n);
				}
                
                 //插入字符，默认给\0  例：abcde->abcdefgh(或abcde\0\0\0)
				for (size_t i = _size; i < n; ++i)
				{
					_str[i] = ch;
				}

				_size = n;//将size变成n
				_str[_size] = '\0';//最后位置再给一个\0
			}
		}

插入数据和删除数据

        void push_back(char ch)//尾插一个字符
		{
			//if (_size == _capacity)//扩容
			//{
			//	size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
			//	reserve(newcapacity);
			//}

			//_str[_size] = ch;//最后一个位置给新字符
			//++_size;
			//_str[_size] = '\0';//再把\0加进去
			
			insert(_size, ch);//复用

		}

		void append(const char* str)//尾插字符串
		{
			//size_t len = strlen(str);
			//if (_size + len > _capacity)//若原有的空间+新字符串的空间>容量 就要扩容
			//{
			//	reserve(_size + len);
			//}

			//strcpy(_str + _size, str);//从_str + _size的位置开始把新的字符串拷贝进去
			//_size += len;

			insert(_size, str);//复用
		}

		string& operator+=(char ch)//插入字符
		{
			this->push_back(ch);
			return *this;
		}

		string& operator+=(const char* str)//插入字符串，和上面代码构成函数重载
		{
			this->append(str);
			return *this;
		}

		string& insert(size_t pos, char ch)//在pos位置插入一个字符
		{
			assert(pos <= _size);
			if (_size == _capacity)//扩容
			{
				size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
		 		reserve(newcapacity);
			}

			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + 1] = _str[end];
				--end;
			}
			_str[pos] = ch;
			++_size;
			return *this;
		}

		string& insert(size_t pos, const char* str)//在pos位置插入一个字符串
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)//若原有的空间+新字符串的空间>容量 就要扩容
			{
				reserve(_size + len);
			}

			int end=_size;
			while (end >= (int)pos)//挪动数据,强制类型转换避免越界
			{
				_str[end + len] = _str[end];
				--end;
			}

			//for (size_t i=0; i < len; ++i)//拷贝
			//{
			//	_str[pos++] = str[i];
			//}

			strncpy(_str + pos, str, len);//用库函数拷贝len个字符，不会拷贝\0
			_size += len;
			return *this;
		}

        string& erase(size_t pos, size_t len = npos)//从pos位置开始删除n个字符
		{
			assert(pos < _size);
			if (len >= _size - pos)//删除刚好n个，超过n或nops个字符
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t i = pos + len;
				while (i <= _size)
				{
					/*_str[i-len] = _str[i];
					++i;*/ //同下

					_str[pos++] = _str[i++];

				}
				_size -= len;
			}

			return *this;
		}

查找

        size_t find(char ch, size_t pos = 0)//寻找字符，返回下标
		{
			for (size_t i = pos; i < _size; ++i)
			{
				if (_str[i] == ch)
				{
					return i;
				}
			}

			return npos;
		}

        size_t find(const char* str, size_t pos = 0)//寻找子字符串
		{
			char* p = strstr(_str, str);
            //C语言中寻找子字符串的库函数，找到了返回首字符的地址，没找到返回nullptr
			if (p == nullptr)//找不到返回npos
			{
				return npos;
			}
			else
				return (p - _str);//找到返回下标
		}

operator运算符重载

        bool operator<(const string& s)
   		{
			int ret = strcmp(_str, s._str);
			return ret < 0;
		}

		bool operator==(const string& s)
		{
			int ret = strcmp(_str, s._str);
			return ret == 0;
		}

		bool operator<=(const string& s)
		{
			return *this < s || *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);
		}

        char& operator[](size_t i)//返回pos下标的字符
		{
			assert(i < _size);//访问的是有效字符
			return _str[i];
		}

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


        istream& operator>> (istream& in, string& s) //重载输入
	 {
		while (1)
		{
			char ch;
			//in >> ch;//不能用这个
			ch = in.get();//get()获取一个字符
			if (ch == ' ' || ch == '\n')//getline函数只需要把ch == ' ' 去掉即可
			{
				break;
			}
			else
			{
				s += ch;//复用+=
			}
		}
		return in;
	}


	ostream& operator<<(ostream& out, const string& s)//重载输出
	{
		for (size_t i = 0; i < s.size(); ++i)
		{
			out << s[i];
		}
		return out;
	}

代码整合+测试

namespace LXQ2//模拟实现string
{
	class string
	{
	public:

        //将以上代码拷贝进来
    
    private:
		char* _str;
		size_t _size;//_size是有多少个有效字符
		size_t _capacity;//_capacity是能存多少有效字符
		static size_t npos;
	};
	size_t string::npos = -1;

    void test1()
	{
		string s1;
		string s2("hello");
		cout << s1 << endl;
		cout << s2 << endl;
		cout << s1.c_str() << endl;
		cout << s2.c_str() << endl;

		for (size_t i = 0; i < s2.size(); ++i)
		{
			s2[i] += 1;
			cout << s2[i] << " ";
		}
		cout << endl;

		string::iterator it2 = s2.begin();
		while (it2 != s2.end())//end返回的是size（）+1的位置
		{
			*it2 -= 1;
			cout << *it2 << " ";
			++(it2);
		}
		cout << endl;

		for (auto e : s2)//会被编译器替换为迭代器
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test2()
	{
		string s1("hello");
		cout << s1 << endl;
		s1.push_back(' ');
		s1.push_back('8');
		cout << s1 << endl;
		s1.push_back('j');
		s1.append(" gvgger25698gergergherhyr154169");
		cout << s1 << endl;
		s1 += 'd';
		s1 += "6546546gdg";

		cout << s1 << endl;
	}

	void test3()
	{
		string s1("hello");
		s1.insert(1, 'g');
		s1.insert(0, "60000");
		cout << s1 << endl;
		s1 += "666gfjg";
		cout << s1 << endl;

		/*string s2("hello");
		s2.reserve(10);
		cout << s2 << endl;
		cout << s2.size() << endl;
		cout << s2.capacity() << endl << endl;;

		s2.resize(8, 'x');
		cout << s2 << endl;
		cout << s2.size() << endl;
		cout << s2.capacity() << endl << endl;;

		s2.resize(18, 'a');
		cout << s2 << endl;
		cout << s2.size() << endl;
		cout << s2.capacity() << endl << endl;;

		s2.resize(2);
		cout << s2 << endl;
		cout << s2.size() << endl;
		cout << s2.capacity() << endl;*/
	}

	void test4()
	{
		string s1("helloworld");
		s1.erase(5, 2);
		cout << s1 << endl;
		s1.erase(5, 4);
		cout << s1 << endl;


		string s2("abcdefg");
		cout << s2.find("def") << endl;
		cout << s2.find("defx") << endl;

	}

	void test5()
	{
		string s1("abc");
		s1.insert(1,'c');
		cout << s1 << endl;
		string s2=s1.insert(3,"jkgdrgrhj000");
		cout << s2 << endl;
	}

}

GDYJLXQ
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
STL中string类的用法及其模拟实现
weixin_45897952的博客
04-28 1013
目录 一、string类的默认存储字符类型： 二、string类的使用： 1.创建对象 2.三种遍历sting的方式： 2.1.for+[]的方式： 2.2.迭代器： 2.3.范围for遍历（其实也是依赖类中的迭代器进行遍历元素） 3.插入数据的方式： 4.删除数据 5.reserve和resize（扩容操作） 5.1.resize: 5.2.reserve： 5.3.疑问(resize和reserve两种平台下的扩容规律)？ 6.c_str() 7.在字符串中找出子串 8.
STL之string模拟实现
m0_73904148的博客
04-07 855
如果要实现简易版的string 无需涉及增容问题，成员变量可以不用存储容量和元素个数。
【C++】STL——string模拟实现
M的博客
06-07 2812
string模拟实现
【C++】STL之string类的模拟实现
Dooo_yh的博客
05-09 631
STL的string模拟实现，帮助了解其底层原理
【C++】STL-string模拟实现
chuxinchangcun的博客
12-22 6075
public:string是一个管理字符数组的类,要求这个字符数组结尾用\0标识1.拷贝构造和赋值重载实现深拷贝2.增删查找的相关接口(跟顺序表类似)3.重载了一些常见的运算符 如: > < >> 加const2.只写接口函数 ->不加const3.可读可写接口函数 ->分为加const版本和不加const版本。
【C++】-- STL之String模拟实现
局部变量和全局变量
05-20 1132
string的模拟实现，包括string类的构造、拷贝构造、赋值运算符重载、析构、迭代器、swap、operator[ ]、size()、c_str()、reserve() 、resize()、push_back()、append()、operator+=()、insert()、erase()、find()、operator>、operator==、operator>=、operator<、operator<=、operator!=、clear()、operator<<、operator>>函数
C++ [STL之string模拟实现]
ARMCSKGT的博客
05-19 5646
前面我们介绍了STL容器string的部分接口使用，有了string使我们对字符串的操作如鱼得水，其实string不止于使用方便，其实现也有许多我们值得学习的地方，本节将为您介绍string常用接口的代码实现！
c++STL(string底层模拟实现)
m0_51694071的博客
12-15 1170
C++ string 底层接口实现
STL详解 - string类的模拟实现
天行健、君子以自强不息
06-17 854
string类的模拟实现以及深拷贝、浅拷贝问题
STL::string 模拟实现
aseraphe的博客
04-21 860
STL::string模拟实现 （详解）
STL库string类的模拟实现
02-28
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。 5. 注意，这个类独立于所...
STL中string类模拟实现源码
08-06
内容简介，涵盖内容广泛。源码实现参照STL源码。
C++STL库String类实现
RandyLambert的博客
01-13 963
前言：按照源码中String类的设计方式实现简单的写了一个myString，参考C++官网中的标准stringAPI完成几乎所有的String类的方法，尽量与源码实现风格类似，有部分没实现有的功能之间相似度较高，重复工作意义不大就没写，有的是没办法写。 亲自在我写的数据结构课设哈弗曼树中使用，没有出现特殊问题，自己测试也没有出问题，如果哪里有错希望大家可以给我指出来。 (一) 关于扩容 在开始...
【C++】深入理解C++模板：从基础到进阶
2403_86785171的博客
09-01 652
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
c++命令模式
qq_71286244的博客
08-30 4644
c++命令模式详细介绍
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1257
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
MySQL 使用C语言链接
最新发布
JK01WYX的博客
09-02 1640
mysql_get_client_info() ; msql_real_connect() ; mysql_query() ; mysql_store_result() ; mysql_num_rows() ; mysql_num_fields() ; mysql_fetch_fields() ; mysql_fetch_fields() ; mysql_close()
c++11新特性-智能指针
SuperYang_的博客
09-01 1134
智能指针RAII(Resource Acquisition Is Initialization)，是一种利用对象的生命周期来管理资源的技术。如果我们采用传统的new/delete来申请和释放资源，如果忘记调用delete，或者在调用delete之前程序抛出异常，都会导致内存泄漏问题，如代码1.1，Func函数中的new p2和Div都可能抛异常，导致后面的delete没有执行从而引发内存泄漏，采用智能指针对资源进行管理，能够杜绝这类问题。代码1.1：因异常引发的内存泄漏throw "除0错误";
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 4175
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++模拟实现string类的深浅拷贝解析
本文档介绍了如何模拟实现C++中的`string`类，重点讨论了深浅拷贝的概念，包括构造函数、析构函数以及拷贝构造函数的实现。提供了源代码链接供参考。 在C++中，`std::string`是一个非常常用的类，用于处理字符串。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值