深入了解string类接口(实现string类)

最新推荐文章于 2024-03-14 22:54:14 发布
最新推荐文章于 2024-03-14 22:54:14 发布
阅读量528 收藏
点赞数
分类专栏： C++ 文章标签： string类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57023347/article/details/118798664
版权
本文详细介绍了如何从零开始实现C++中的string类，包括构造函数、析构函数、赋值操作符的重载，以及容量函数、operator[]、c_str函数的实现。此外，还涵盖了resize、reserve、插入、删除、查找和比较函数的详细代码。通过这个过程，读者可以深入了解C++ string类的底层工作原理，并能更好地掌握其使用。
摘要由CSDN通过智能技术生成

目录

前言

一.构造，析构函数和赋值操作符的重载

二.容量函数，operator[]重载函数和c_str函数

三.resize和reserve函数

四.插入和删除函数

五.查找函数和比较函数

六.operator<<和operator>>操作符重载

七.完整代码

前言

在博客C++ string类常用接口一文中我们熟知了C++string类的一些常用接口的使用，在本文时来简单实现一下这些常用的接口，带你了解string类的底层原理，然你能轻而易举的掌握string类的使用。

说明注意点：在我们自己实现string类时，如果你的类名用的与标准库类名相同时，需要一个命名空间将其与标准库里的string类分开。

下面是代码的分开实现，完整代码在最下面给出。

一.构造，析构函数和赋值操作符的重载

//要在堆上开辟空间将字符串拷贝过去，不能直接在初始化列表里初始化，否则不可修改
		//空字符串也要开辟一个空间，放\0
		//拷贝构造函数
		string(const char *str="")
		:_str(new char[strlen(str)+1])
		{
			strcpy(_str, str);
			_size = strlen(str);
			_capacity = _size;
		}
		//拷贝构造函数
		string(const string& s){
			_str = new char[strlen(s._str) + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
			
		}
		//析构函数
		~string(){
			delete[] _str;
			_str = nullptr;
		}
		//赋值操作符
		string& operator=(const string& s){
			if (this != &s){
				char *newstr = new char[strlen(s._str) + 1];
				strcpy(newstr, s._str);
                //需要delete之前的——str空间，避免内存泄漏
				delete[] _str;
				_str = newstr;
				_size = s._size;
				_capacity = s._capacity;
				
			}
			return *this;
		}

注意：拷贝构造和赋值操作符重载函数，这里蕴含着深浅拷贝问题。如果不定义着两个函数，编译器会自动生成，但是仅仅只是按字节进行拷贝，也就是值拷贝/浅拷贝。在上面函数中，如果只是进行浅拷贝，两字符指针变量指向堆上的同一块空间。当对象出作用域时，调用析构函数，但是同一块空间不能释放两次，会导致程序奔溃。

解决方法就是使用深拷贝：

再堆上再申请一块空间，将拷贝值或者赋值值copy过去。将需要被赋值或者被拷贝的对象的字符指针指向新申请的空间。

二.容量函数，operator[]重载函数和c_str函数

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

		size_t size()const{
			return _size;
		}
		size_t capacity()const{
			return _capacity;
		}
		const char *c_str(){
			return _str;
		}

三.resize和reserve函数

//不需要返回值，在函数体里this改变了
//三种情况，
//len小于_size,
//len大于_szie小于_capacity
//len大于_capacity
		void resize(size_t len, char c = '\0'){
			if (len > _size){
				if (len > _capacity){
					char *temp = new char[len + 1];
					strcpy(temp, _str);
					delete[] _str;
					_str = temp;
					_capacity = len;
				}
				//用memset函数，或者用循环
				memset(_str + _size, c, len - _size);

			}
			_size = len;
			_str[_size] = '\0';
		}
		void reserve(size_t newcapacity){
			//只有大于容量时才扩容
			if (newcapacity > _capacity){
				char *newstr = new char[newcapacity + 1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;
				_capacity = newcapacity;

			}
		}

四.插入和删除函数

插入时注意是否要扩容。

再中间插入要将后面的往后移，再中间删除要将后面的往前移。

		void push_back(char c){
			if (_size == _capacity){
				//细节 判断容量是否等于0
				size_t newcapacity = _capacity == 0 ? 2 : 2 * _capacity;
				//加1  预留\0位置
				char *newstr = new char[newcapacity+1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;
				_capacity = newcapacity;
			}
			_str[_size++] = c;
			//要在末尾加上\0
			_str[_size] = '\0';
			
		}

		void append(const char *s){
			size_t len = strlen(s) + _size;
			if (len > _capacity){
				char *newstr = new char[len + 1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;
				_capacity = len;
			}
			strcpy(_str + _size, s);
			_size = len;
			
		}
		//复用push_back
		string& operator+=(char c){
			push_back(c);
			return *this;
		}
		//服用append
		string& operator+=(const char *s){
			append(s);
			return *this;
		}
        string& insert(size_t pos, char c){
			assert(pos < _size);
				if (_size==_capacity){
					int newcapacity = _capacity == 0 ? 2 : 2*_capacity;
					reserve(newcapacity);
				}
				size_t end = _size;
				while (end >= pos){
					_str[end + 1] = _str[end];
					end--;
				}
				_str[pos] = c;
				_size++;

				return *this;

		}
		string& insert(size_t pos, const char *s){
			assert(pos < _size);
			int len = strlen(s);
			if (len + _size>_capacity){
				reserve(len + _size);
			}
			size_t end = _size;
			while (end >= pos){
				_str[end + len] = _str[end];
				end--;
			}
			strncpy(_str + pos, s, len);	
			_size += len;
			return *this;

		}
		//两种情况，删除长度加上位置小于_size，删除长度加上位置大于等于_size。
		string& erase(size_t pos, size_t len = npos){
			assert(pos < _size);
			//用减比较好，防止越界，加的话npos最大值，加上一值容易越界
			if (len >= _size - pos){
				_str[pos] = '\0';
				_size = pos;
			}
			else{
				size_t i = pos + len;
				while (i <= _size){
					_str[pos++] = _str[i];
					i++;
				}
				_size -= len;
			}
			return *this;

		}

五.查找函数和比较函数

        //利用C语言字符串函数
        size_t find(char c){
			for (size_t i = 0; i < size(); i++){
				if (_str[i] == c){
					return i;
				}
			}
			return npos;
		}

		size_t find(char *s){
			//使用C语言字符串函数
			char *ret = strstr(_str, s);
			if (ret == NULL){
				return npos;
			}
			return ret - _str;

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

		}
		bool operator==(const string& s)const{
			int key = strcmp(_str, s._str);
			return key == 0;
		}
		bool operator<=(const string& s)const{
			return *this<s || *this == s;
		}
		bool operator>(const string& s)const{
			return !(*this <= s);

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

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

六.operator<<和operator>>操作符重载

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

	istream& operator>>(istream& in, string& s){

		while (1){
			//cin时istream类的对象，get时istream类成员函数
			char ch = in.get();
			if (ch == ' ' || ch == '\n'){
				break;
			}
            //+=里会开辟空间
			s += ch;
		}
		return in;

	}

具体细节看下面完整代码，还增加了迭代器的实现

七.完整代码

#include<iostream>
#include<assert.h>
#include<string>
#include<Windows.h>
#pragma warning(disable:4996)
using namespace std;

namespace my{
	class string{
		friend istream& operator>>(istream& in, string& s);
	public:
		typedef char* iterator;
		iterator begin(){
			return _str;
		}
		iterator end(){
			return _str + _size;
		}
		//要在堆上开辟空间将字符串拷贝过去，不能直接在初始化列表里初始化，否则不可修改
		//空字符串也要开辟一个空间，放\0
		//拷贝构造函数
		string(const char *str="")
		:_str(new char[strlen(str)+1])
		{
			strcpy(_str, str);
			_size = strlen(str);
			_capacity = _size;
		}
		//拷贝构造函数
		string(const string& s){
			_str = new char[strlen(s._str) + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
			
		}
		//析构函数
		~string(){
			delete[] _str;
			_str = nullptr;
		}
		//赋值操作符
		string& operator=(const string& s){
			if (this != &s){
				char *newstr = new char[strlen(s._str) + 1];
				strcpy(newstr, s._str);
				delete[] _str;
				_str = newstr;
				_size = s._size;
				_capacity = s._capacity;
				
			}
			return *this;
		}

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

		size_t size()const{
			return _size;
		}
		size_t capacity()const{
			return _capacity;
		}
		const char *c_str(){
			return _str;
		}

		void push_back(char c){
			if (_size == _capacity){
				//细节 判断容量是否等于0
				size_t newcapacity = _capacity == 0 ? 2 : 2 * _capacity;
				//加1  预留\0位置
				char *newstr = new char[newcapacity+1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;
				_capacity = newcapacity;
			}
			_str[_size++] = c;
			//要在末尾加上\0
			_str[_size] = '\0';
			
		}

		void append(const char *s){
			size_t len = strlen(s) + _size;
			if (len > _capacity){
				char *newstr = new char[len + 1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;
				_capacity = len;
			}
			strcpy(_str + _size, s);
			_size = len;
			
		}
		//服用push_back
		string& operator+=(char c){
			push_back(c);
			return *this;
		}
		//服用append
		string& operator+=(const char *s){
			append(s);
			return *this;
		}
		//不需要返回值，在函数体里this改变了
		void resize(size_t len, char c = '\0'){
			if (len > _size){
				if (len > _capacity){
					char *temp = new char[len + 1];
					strcpy(temp, _str);
					delete[] _str;
					_str = temp;
					_capacity = len;
				}
				//用memset函数
				memset(_str + _size, c, len - _size);

			}
			_size = len;
			_str[_size] = '\0';
		}
		void reserve(size_t newcapacity){
			//只有大于容量时才扩容
			if (newcapacity > _capacity){
				char *newstr = new char[newcapacity + 1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;
				_capacity = newcapacity;

			}
		}
		string& insert(size_t pos, char c){
			assert(pos < _size);
				if (_size==_capacity){
					int newcapacity = _capacity == 0 ? 2 : 2*_capacity;
					reserve(newcapacity);
				}
				size_t end = _size;
				while (end >= pos){
					_str[end + 1] = _str[end];
					end--;
				}
				_str[pos] = c;
				_size++;

				return *this;

		}
		string& insert(size_t pos, const char *s){
			assert(pos < _size);
			int len = strlen(s);
			if (len + _size>_capacity){
				reserve(len + _size);
			}
			size_t end = _size;
			while (end >= pos){
				_str[end + len] = _str[end];
				end--;
			}
			strncpy(_str + pos, s, len);	
			_size += len;
			return *this;

		}
		//两种情况，删除长度加上位置小于_size，删除长度加上位置大于等于_size。
		string& erase(size_t pos, size_t len = npos){
			assert(pos < _size);
			//用减比较好，防止越界，加的话npos最大值，加上一值容易越界
			if (len >= _size - pos){
				_str[pos] = '\0';
				_size = pos;
			}
			else{
				size_t i = pos + len;
				while (i <= _size){
					_str[pos++] = _str[i];
					i++;
				}
				_size -= len;
			}
			return *this;

		}

		size_t find(char c){
			for (size_t i = 0; i < size(); i++){
				if (_str[i] == c){
					return i;
				}
			}
			return npos;
		}

		size_t find(char *s){
			//使用C语言字符串函数
			char *ret = strstr(_str, s);
			if (ret == NULL){
				return npos;
			}
			return ret - _str;

		}

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

		}
		bool operator==(const string& s)const{
			int key = strcmp(_str, s._str);
			return key == 0;
		}
		bool operator<=(const string& s)const{
			return *this<s || *this == s;
		}
		bool operator>(const string& s)const{
			return !(*this <= s);

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

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




	private:
		char *_str;
		size_t _size;
		size_t _capacity;

		static size_t npos;
	};

	size_t string::npos = -1;

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

	istream& operator>>(istream& in, string& s){

		while (1){
			//cin时istream类的对象，get时istream类成员函数
			char ch = in.get();
			if (ch == ' ' || ch == '\n'){
				break;
			}
			s += ch;
		}
		return in;

	}

	
}

两片空白
关注
专栏目录
string类相关接口使用方法
sqjddb的博客
02-28 394
一、string类简介 二、string常用接口 1.构造string相关接口 2.容量相关接口 3.string增删查改相关接口 三、string类非成员函数 四、遍历string的方法 1.通过 [ ] 遍历 2.通过迭代器遍历 3.通过范围for
C++下基于QT的String类自己实现
08-31
通过阅读和分析这些文件，你可以深入理解自定义`String`类的具体实现细节，并可能从中学习到内存管理、面向对象编程以及C++语言特性的实际应用。如果有任何疑问，按照描述中的提示，你可以与作者进行探讨，进一步...
string类接口实现
fiskerzero的博客
11-08 219
#include<string> #include<stdio.h> #include<cassert> using namespace std; /*方法一: string的传统版实现*/ class string{ public: //构造函数 string(const char* str = "") { // 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下 if (nu
轻松掌握string类常用接口(附模拟实现)（附图解）
Obto_的博客
10-18 636
本篇对string中的常用接口进行了模拟与解析，进一步帮助读者了解string各个成员函数的使用，详细讲述string类的写时拷贝的特性以及深浅拷贝的区别与实现方式
string接口
weixin_41446512的博客
08-31 318
一、构造string 1.基本构造 2.三种遍历 （1）for遍历：下标+[ ] （2）迭代器遍历 [begin(),end())：end()返回的不是最后一个数据位置的迭代器，返回的是最后一个位置下一个位置 也要注意：C++中凡是给迭代器一般都是[）左闭右开的区间，迭代器是类似指针的东西 （3）范围for，C++11的标准 依次取容器中的数据，赋值给e(随意取的一个字母)，自动判断结束、 for (auto& e : s3) 若要修改，auto必须加&，告诉其是别名，只是拷贝 二
JAVA实验报告四(实现String类).doc
09-30
在以后的学习中，我们可以继续深入学习 String 类的实现原理，并掌握更多的字符串操作方法。 附录 在本实验报告中，我们提供了详细的实现过程和结果，我们可以通过这些结果来了解 String 类的实现原理，并掌握基于...
！实例研究：字符串类String.rar_字符串类_类String重载
09-23
`string2.h`和`fig4_3.h`可能是头文件，定义了类`MyString`以及相关接口，而`.bak`文件则是这些源文件的备份。 `.obj`和`.tds`文件是编译过程中的中间产物。`.obj`文件是对象文件，包含了编译器生成的机器码和符号...
第12章04自定义字符串类_String.zip_综合类 自定义string
09-21
在编程领域，自定义字符串类...在实际编码过程中，每个知识点都需要深入理解和实践，才能确保`_String`类的稳定性和效率。学习和理解这些概念，不仅对理解字符串处理的基础原理有帮助，也是提升编程能力的重要步骤。
string类中英文文档
11-22
在阅读提供的`string类_中文.pdf`和`string类_英文.pdf`文档时，可以深入了解这两个字符串类的细节，包括它们的高级功能、性能优化和使用技巧。对于C++和MFC开发者来说，理解和熟练使用`std::string`和`CString`是...
string类的各个接口以及用法
itxiaobaiiii的博客
05-28 357
string类 string的接口 #include<stdio.h> #include<iostream> using namespace std; void test() { string str;//创建一个空的字符串 string copy(str);//复制一个字符串 string str2("abc");//创建一个字符串 string substr(str2, 1, 2);//从1位置取出str2的2个字符 string str3("12345678", 5)
c++ string知识总结
qq_44778236的博客
09-19 155
一.标准库中的string 1.string类 1.1 string是表示字符串的字符串类 1.2该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 1.3string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string; 1.4. 不...
string常用接口
swo_ows的博客
12-04 284
一、string string是表示字符串的字符串类 头文件#include &lt;string&gt;还得写using namespace std; 底层typedef basic_string&lt;char&gt; string; 不能操作多字节或者变长字符的序列 二、成员函数 1、构造函数 函数名称 功能说明 string(); 构造一个空字符串 stri...
string类的接口说明
didi1663478999的博客
01-22 1178
1.string类对象的常见构造 看下面的代码： #include&amp;lt;iostream&amp;gt; #include&amp;lt;string&amp;gt; using namespace std; int main() { string s1; //构造空的string类对象，为空 string s2(&quot;hello bit&quot;); //构造类对象 string s3(
【从零开始学c++】———模拟实现string类（常用接口的实现）
sjp11的博客
07-25 901
string1.前言2.string类常用接口实现3.总结 1.前言 之前学到了string类常用接口的后，我很好奇string类在底层是怎样实现的，在由之前学习到c++有关的之后，所以我打算模拟实现一下string类常用的接口，以便加深我对之前的知识的理解，和更好的去使用string类，比如在哪些场景使用哪些接口较为合适。接下来我会用c++来模拟实现各个接口。 2.string类常用接口实现 #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream&g.
String（三）———接口大全
SAKURAjinx的博客
11-02 1045
这里find返回值返回的是size_t，而不是int，C语言通常下标返回都是int，如果找不到对应元素就返回负值（如-1），但是这里设计的返回的是std::npos，不同平台下实现的具体值不一样。assign是用一个新的字符串赋值给原先的（覆盖原先的），使用方法与 operator+=、insert大同小异，只不过不是拼接字符串，而是覆盖。缩减string的容量capacity，使得它能符合size 的大小，不一定是要和size一样大，可以比size略大，只要在合理范围内。
string接口[小白理解篇]
最新发布
2301_78524918的博客
03-14 412
作文目的本文是为了加深对string底层函数的一点理解(请勿与底层源码混为一谈)，下面从模拟与注意项出发。
string接口简单使用
qq_45672975的博客
10-30 440
string使用整理 #include <string> #include <iostream> using namespace std; void test1() { //字符串的相关构造 /*string s1; string s2("123"); string s3(s2); string s4 = "123456";*/ //size: 返回有效字符的个数---和\0有区别 //length:返回有效字符的个数 string s1("123"); co
String类接口
徐佳佳的博客
11-12 306
String类的常用接口 1.构造和析构 1.string() // 构造空的string类对象 2.string(const char* s) // 用C-string来构造string类对象 3.string(size_t n,char c) // string类对象包含n个字符c 4.string(const string&s) // 拷贝构造 5.string(const string&s,size_t pos,size_t n) // 从pos位置开始拷贝n个字符构造strin
深入理解JDK中的不可变类String
"本文主要探讨了JDK中的不可变类String...了解并理解JDK中String类的不可变性对于深入学习Java和优化代码性能至关重要。通过遵循不可变类的原则，我们可以设计出更安全、更可靠的类，并在编程实践中充分利用这些特性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值