【C++学习笔记】----模拟实现string类及成员函数（详解）

最新推荐文章于 2023-08-10 18:26:32 发布
最新推荐文章于 2023-08-10 18:26:32 发布
阅读量240 收藏
点赞数 1
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41152046/article/details/106448182
版权

1.简介

string类是表示字符串的字符类，是一块连续的空间存储字符串，并且可以通过统一接口，实现插入，删除，尾插，查找，迭代器遍历等一系列操作。

2.代码展示

#define _CRT_SECURE_NO_WARNINGS 1;
#include<iostream>
#include<assert.h>
using namespace std;
namespace xff {
	class string {
	public:
		typedef char* iterator;
		//迭代器
		iterator begin() {
			return _str;
		}
		iterator rbegin() {	//最后一个字符
			return _str+_size-1;
		}
		iterator end() {
			return _str + _size;
		}
		iterator rend() {	//第一个字符的前一个
			return --_str;
		}
		//构造函数
		string(const char* str=""){
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		//拷贝构造
		string(const string& s)
				:_str(nullptr)
				,_size(0)
				,_capacity(0)
		{
			string tmp(s._str);
			this->swap(tmp);
		}
		//析构函数
		~string(){
			if (_str) {
				delete[] _str;
				_str = nullptr;
				_size = _capacity = 0; 
			}
		}
		//=
		string operator=(string s) {
			this->swap(s);
			return *this;
		}
		//size
		size_t  size()const {
			return _size;
		}
		//capacity
		size_t capacity()const {
			return _capacity;
		}
		//[]
		char& operator[](size_t index) {
			assert(index < _size);
			return _str[index];
		}
		//[]const
		const char& operator[](size_t index)const {
			assert(index < _size);
			return _str[index];
		}
		//c_str
		const char* c_str() {
			return _str;
		}
		void swap( string& s) {
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		//判断是否为空
		bool empty() {
			if (_size == 0) {
				return true;
			}
			return false;
		}
		//reserve预留空间
		void reserve(size_t num) {
			if (num > _capacity) {
				char* newstr = new char[num + 1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;
				_capacity = num;
			}
		}
		//push_back
		void push_back(const char ch) {
			if (_size == _capacity) {
				size_t newcapacity = _capacity == 0 ? 2 : 2*_capacity;
				reserve(newcapacity);
			}
			_str[_size++] = ch;
			_str[_size] = '\0';
		}
		//operator+=()字符
		 string& operator+=(const char ch) {
			this->push_back(ch);
			return *this;
		}
		 //operator+=()字符串
		 string& operator+=(const char* str) {
			this->append(str);
			return *this;
		}
		//append加字符串
		void append(const char* str = "") {
			size_t len = strlen(str);
			if (len + _size > _capacity) {
				/*size_t newcapacity = _capacity = len + _size;
				char* newstr = new char[newcapacity + 1];
				strcpy(newstr, _str);
				delete[] _str;
				_str = newstr;*/
				reserve(len + _size);
			}
			strcpy(_str + _size, str);
			_size += len;
		}
		//将有效字符串置0
		void clear() {
			_size = 0;
		}
		//resize重置有效字符个数
		//小于有效字符个数就截
		//大于补字符
		void resize(size_t num, const char ch ='\0') {
			if (num <= _size) {
				_size = num;
			}
			else {
				while (num - _size > 0) {
					push_back(ch);
				}
			}
		}
		//插入单个字符
		string& insert(size_t pos, const char ch) {
			assert(pos < _size);
			size_t size = _size;
			if (_size == _capacity) {
				size_t newcapacity = _capacity == 0 ? 2 : 2 * _capacity;
				reserve(newcapacity);
			}
			while (pos<=size) 
				{
					_str[size+1] = _str[size];
					--size;
				}
				_str[pos] = ch;
				++_size;	
				return *this;
		}
		//插入字符串
		string& insert(size_t pos, const char* str) {
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size+len > _capacity) {
				reserve(_size + len);
			}
			int size = _size;
			while ((int)pos <= size)//无符号-1是最大值，容易死循环
			{
				_str[size+len] = _str[size];
				--size;
			}
			strncpy(_str + pos, str, len);//不要复制这个字符串尾部的空格，不然会覆盖移动的字符
			_size += len;
			return *this;
		}
		//删除
		//大于等于pos到_size全删
		//小于保留余下的，并且移动
		string& erase(size_t pos,size_t len = npos) {
			assert(pos < _size);
			if (len>=_size-pos) {
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				size_t i = pos+len;
				while (i <= _size) {
					_str[pos++] = _str[i++];	
				}
				_size -= len;
			}
			return *this;
		}
		//find字符
		size_t find(const char ch, size_t pos = 0) {
			for (size_t i = pos; i < _size; ++i) {
				if (_str[i] == ch) {
					return i;
				}
			}
			return npos;
		}
		//find字符串
		size_t find(const char* str, size_t pos = 0) {
			size_t len = strlen(str);
			size_t dst = pos;
			while (dst<_size) {
				size_t src = 0;
				pos = dst;
				while (src<len&&_str[dst] == str[src]) {
					++src;
					++dst;
				}
				if (src == len) {
					return pos;
				}
				++dst;
			}
			return npos;
		}
		bool operator==(const string& s) {
			int ret = strcmp(_str, s._str);
			if (ret == 0)
				return true;
			return false;
		}
		bool operator!=(const string& s) {
			if (*this == s) {
				return false;
			}
			return true;
		}
		bool operator>(const string& s) {
			int ret = strcmp(_str, s._str);
			if (ret > 0)
				return true;
			return false;
		}
		bool operator<(const string& s) {
			int ret = strcmp(_str, s._str);
			if (ret < 0)
				return true;
			return false;
		}
		bool operator>=(const string& s) {
			if (*this < s) {
				return false;
			}
			return true;
		}
		bool operator<=(const string& s) {
			if (*this > s) {
				return false;
			}
			return true;
		}
		 const string substr(size_t pos, size_t n=npos) {
			assert(pos < _size);
			if (_size-pos<n) {
				n = _size - pos;
			}
			char* newstr = new char[n + 1];
			strncpy(newstr,_str + pos, n);
			newstr[n] = '\0';
			string s(newstr);
			delete[] newstr;
			return s;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static size_t npos;
	};
	const 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) {
			char ch;
			ch = _in.get();//输入的全接收，包括空格换行
			if (ch == '\n') {
				break;
			}
			else
			{
				s += ch;
			}
		}	
		return _in;
	}
	void test_String1() {
		string s1;
		//cout << s1 << endl;
		string s2("hello");
		//cout << s2 << endl;
		//cout << s2.size() << "  " << s2.capacity() << endl;
		string s3;
		s3 = s2;
		cout << s3 << endl;
		//cin >> s1;
		//cout << s1 << "  " <<s1.empty()<<endl;
		s2 += "world";
		cout << s2 << endl;
		//迭代器访问	
		/*string::iterator it = s3.begin();
		while (it != s3.end()) {
			cout << *it << " ";
			++it;
		}
		//for
		for (auto e : s3) {
			cout << e;
		}*/
		//s2.reserve(15);
		//s2.reserve(3);
		//cout << s2 << endl;
		//cout << s2.size() << "  " << s2.capacity() << endl;
		//s3.resize(2);
		//s3.resize(10);
		//cout << s3 << endl;
		//cout << s3.size() << "  " << s3.capacity() << endl;
		//s3.push_back(' ');
		//cout << s3 << " ";
		//cout << s3.size() << "  " << s3.capacity() << endl;
		//s3.append("world!");
		//cout << s3 << " ";
		//cout << s3.size() << "  " << s3.capacity() << endl;
		//s3.insert(0,"a");
		//s3.insert(10, "abc");
		//s3.insert(5,"a");
		//s3.insert(1, 'a');
		//s3.erase(2, 8);
		//s3.erase(0);
		//s3.erase(2, 2);
		//cout << s3 << " ";
		//cout << s3.size() << "  " << s3.capacity() << endl;
		//size_t num1 =s3.find('l');
		//size_t num2 = s2.find("q",1);
		//cout << num1 << " " << num2 << endl;
		//cout << (s3>=s2)<< endl;
		//cout << s3.substr(0, 8);
	}
}


#include<string>
int main() {
	string s1("hello");
	//cout<<s1.substr(2);
	//s1.insert(1,"ac");
	//s1 += " world!";
	//s1.push_back('!');
	//s1.append("world!");
	//s1.reserve(16);
	//s1.resize(14,'a');
	//s1.clear();
	//s1.erase();
	//cout << s1.substr(2);
	//cout << s1 << endl;
	//int num = s1.find("ello",0);
	//cout << s1<<" "<<s1.size()<<" "<<s1.capacity() <<endl;
	/*string::iterator it = s1.begin();
	while (it != s1.end()) {
		cout << *it;
		++it;
		}
	cout << endl;
	string::reverse_iterator rit = s1.rbegin();
	while (rit != s1.rend()) {
		cout << *rit;
		++rit;
	}*/
	xff::test_String1();
	system("pause");
	return 0;
}

3.总结

1.迭代器是c++ STL组件之一，是通用的遍历容器的方式，讲操作和底层实现分离，我们只需要调用对应的接口，就能实现对容器的遍历，针对不同的数据结构，有规范接口的作用。
2.实现插入删除等操作时，迭代器会失效，可能会出现重新分配内存空间的情况，迭代器就失效了。
3.clear()清除有效字符，容量不变。
4.reserve(size_t n)预留空间，不改变有效字符个数，扩容作用。
5.resize(size_t n，char ch)改变有效字符个数，小于有效字符个数就只保留到n,大于当前有效字符个数就补ch到n，前面的字符不变。
6.push_back（ch）尾部插入，不可以为空，可以插空格。
7.append(str) 尾插字符串。
8.erase(pos,n)从pos开始删除n个字符，默认是最大值size_t npos=-1。
9.insert(_size,str)只能插入字符串，并且小于等于_size。
10.find(str/ch,pos)从pos位置开始查找str/ch，找到返回第一个下标，找不到返回npos，rfind反向查找。
11.c_str() 返回C格式字符串，return _str.
12.substr(pos,n)从pos截取n个字符，默认npos，返回字符串。
13.getline string类的非成员函数，获取一行字符串，空格也接收，cin会将\n和空格，作为结束的标志。
14.reverse(s.begin(),s.end())，结尾是需要逆置的字符的下一个位置。

4.心得体会

通过实现string类，我对string类的认识进一步加强，同时我也更加熟悉构造函数，析构函数等，同时对new,delete的使用更加熟练。初次学习，可能有不对的地方，希望大家指出来，共同进步。

NTZ5bzZKdUw
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#学习笔记-25个经典问题.pdf
12-21
抽象类可以包含实现，可以有字段和构造函数，而接口仅包含方法签名。一个类只能继承一个抽象类，但可以实现多个接口。 19. 别名指示符（using alias directive） using alias directive 用于为命名空间或类型创建...
string类的成员函数
xiebs的博客
09-01 2123
1、swap（s1，s2） —— 交换两个字符串的内容 2、s.length() 和 s.size( ) —— 都表示返回字符的数量 3、s.substr(pos) —— 返回 pos 之后的那半边字符串 4、s.substr(a，pos) ——返回 a 到 pos 之间的字符串 5、+= —— 表示两个字符串合并在一起 ...
c++模板类string成员函数
weixin_46557247的博客
12-18 1278
c++在c语言的基础上扩展了对于字符串的支持，使其使用方式更加多样化，使用者可以根据实际需要选择最佳的使用方式，具有更强的可操作性。 c++继承了c语言中的c风格字符串，并开发出了内置的string类。c语言标准函数库中提供了大量的函数用来操作以’\0’结尾的字符串，比如strcpy、strlen、strcmp、strcat等。c++继续支持这些函数，并且在string类中提供了功能与之一样的成员函数，另外还增加了一些其他的功能。 一．string类构造函数 string类提供了多个构造函数，可以根据数据需
C++入门--string类的实现
m0_74288306的博客
08-10 1557
private://string类的大小//string类的存储容量char* _str;我们定义string类的成员变量有sizecapacity_str，配合我们实现插入、删除、扩容等修改操作函数，并且把我们自己实现的string类成员函数封装在命名空间里面，避免和标准库里面的string类类型、函数冲突。
C++ STL - string 成员函数 + 模拟实现
TPON的博客
08-20 1149
STL - string成员函数 + 模拟实现
C++ 字符串类（string class）使用详解【学习笔记】
Aliven888的博客
09-26 3207
文档声明： 以下资料均属于本人在学习过程中产出的学习笔记，如果错误或者遗漏之处，请多多指正。并且该文档在后期会随着学习的深入不断补充完善。 资料仅供学习交流使用。 作者：Aliven888 1、简述 String class：字符串是代表字符序列的对象。 标准字符串类通过类似于标准字节容器的接口为此类对象提供支持，但增加了专门设计用于单字节字符字符串的功能。 字符串类是basic_string类模板的实例化，该模板使用char（即字节）作为其字符类型，并具有其默认的char_traits和分配器类型（.
PHP学习笔记（二）：变量详解
12-19
这篇学习笔记主要探讨了PHP中的变量，包括它们的定义、命名规则、数据类型、常用函数以及变量声明的方法。 首先，PHP是弱类型语言，这意味着变量的类型不是预先声明的，而是根据所存储的值自动确定。在强类型语言中...
达内内网学习笔记 Java SE核心
03-20
达内的内网学习笔记针对Java SE进行了深入讲解，为初学者提供了全面的学习材料。以下是对这些PDF文件中可能涵盖的重要知识点的详细解析： 1. **Java基础语法**： - 变量与数据类型：包括基本数据类型（如int, ...
JVM性能学习笔记思维导图
最新发布
03-24
本文将根据"JVM性能学习笔记思维导图"的主题，详细阐述JVM的主要组成部分，性能调优的关键点以及相关的工具与实践策略。** 1. **JVM结构与内存模型** - **类装载器(ClassLoader)**：负责加载类文件，确保类在运行...
java jdk8 学习笔记
08-14
2.动态加载类别文档、字符串池（String Pool)等特性为节省内存而设计 3.jdk java development kit java 开发工具集 java se 平台包括jdk与java语言 ，（不知道编程语言是什么？可以这样想 :java 语言 ->类文件...
从string类的实现看C++类的四大函数(面试常见)
12-25
朋友面试的一道面试题，分享给大家，面试官经常会问到的，实现string类的四大基本函数必掌握。 一个C++类一般至少有四大函数，即构造函数、拷贝构造函数、析构函数和赋值函数，一般系统都会默认。但是往往系统默认的并不是我们所期望的，为此我们就有必要自己创造他们。在创造之前必须了解他们的作用和意义，做到有的放矢才能写出有效的函数。 #include <iostream> class CString { friend std::ostream & operator<<(std::ostream &, CString &); public: // 无参数的构造函数
C++简单String类的实现
12-22
我跟很多童鞋一样，目前也在学习C++中，昨天正在学习has-a关系中的包含时，例题是将string类包含的，因为是小白嘛，嘿嘿，为了更深的理解包含以及其他相关问题，果断上机边敲代码边理解咯，既然用到了string类，自己突然想写个简易的string类(毕竟之前书中提到过编写简易string类，但也只是看看，还没来得及自己写一个)于是自己写了一个简易的string类，也算对之前学到的部分知识一个小小的汇总，string类也是很考研小白的内存管理的，这个String类也是我调试了很多遍后没啥问题才敢发出来的，嘻嘻，废话不多说，附上自己写的string类。只写了部分主要功能，其他功能，以后用到后，再
C++ 自己动手简单实现字符串String类
魔筝炼药师
03-29 4775
实现一个自己的String类是一道考验C++基础知识的好题。能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_pData，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。 仔...
string类的两种实现方法及string的一些成员函数的实现
weixin_34150503的博客
03-12 194
string的第一种实现方法：#include<iostream> usingnamespacestd; classString { public: String(char*str="")//构造函数 :_str(newchar[strlen(str)+1]) { strcpy(_str,str); ...
string类及其成员函数总结
qq_31112171的博客
10-30 1383
string类及其成员函数总结
尝试写出类的成员函数实现
jardownload的博客
08-12 601
已知String类定义如下： class String { public: String(const char *str = NULL); // 通用构造函数 String(const String &another); // 拷贝构造函数 ~ String(); // 析构函数 String & operater =(const String &rhs); // 赋值函数 private: ch...
C++ String类的实现
相门码农的专栏
04-22 589
面试的时候被问及了String类的实现，结果没写好...  就当是重新复习一下吧。  下面的程序并没有把String类的所有成员方法实现，只参考教程写了大部分重要的成员函数。   [cpp] view plaincopy #include   #include   using namespace std;      class
C++ string 类 部分成员函数实现（实现COW copy-on-write）
A Light Clean Place
05-02 1179
虽然标题中说实现了·COW，但是事实上是很浪费的，并且命名也很不标准，代码也非常小学生，毕竟初学（给自己找借口.jpg），以后应该还会把这篇找出来认真修改一下的。 Mystring.h： #pragma once #ifndef _MYSTRING_H_ #define _MYSTRING_H_ #include #include using namespace std; class My
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值