【C++】模拟实现string类

最新推荐文章于 2024-04-26 12:39:16 发布
最新推荐文章于 2024-04-26 12:39:16 发布
阅读量564 收藏 1
点赞数 2
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaocx111222333/article/details/115232393
版权

简易写法：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
class String{
private:
	char* _data;
	size_t _size;
public:
	String()//这个是默认构造，默认就是一个空
		: _data(new char[1])
	{
		*_data = '\0';//解引用
	}

	String(const char* data)//参数const
		:_data(new char [strlen(data)+1])
		,_size(strlen(data))
	{
		strcpy(_data, data);
	}


	String(const String& s)//参数const
	{
		String(s._data);
	}

	void Swap(String& s){//注意大写第一个字母
		swap(_data, s._data);
		swap(s._size, s._size);
	}

	String& operator=(String s)//参数值
	{
		Swap(s);
		return *this;
	}

	String(String&& s){
		_data = s._data;
		s._data = nullptr;//移动构造记得置空
		_size = s._size;
	}

	String& operator=(String&& s){//直接交换
		if (_data){
			delete[] _data;
			_data = nullptr;
		}
		Swap(s);
		return *this;
	}

	~String(){
		if (_data){
			delete[] _data;
		}
		_size = 0;
		
	}

	int Size(){
		return _size;
	}

	const char* c_str()const {//const!!!!
		return _data;
	}

	//上面的是基础，在可以增加[],==,<
	char& operator[](size_t pos){
		assert(pos < _size);
		return _data[pos];
	}

	
};
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){
	int a=strcmp(s1.c_str(), s2.c_str());//返回大于等于0就不是小于
	if (a<0){
		return true;
	}
	return false;
}

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
class String{
private:
	size_t _size;  //无符号整数代表存储的大小
	size_t _capacity;
	char* _data; //具体用来存储的内存指针
	static const size_t npos;//const static可以类内定义

public:
	typedef char* iterator;
	typedef const char* const_iterator;//代表着是一个指针指向了不可变的变量
	iterator begin(){
		return _data;
	}
	const_iterator begin() const{ //const可以作为重载的标志（返回值不可以）
		return _data;
	}
	iterator end(){	//刚好是最后一个有效的下一个
		return _data + _size;
	}
	const_iterator end()const{
		return _data + _size;
	}

//这个应该写一个无参构造当默认构造
	String(const char* str = '\0')//一般是常量字符串来赋值的const
		:_size(strlen(str))//strlen是不包括\0的字符串大小
		, _capacity(_size)
		, _data(new char[strlen(str) + 1])//new []用来初始化多个空间[个数]--这里要有/0
	{
		strcpy(_data, str);
	}

	void Swap(String& str){
		swap(_data, str._data);
		swap(_size, str._size);
		swap(_capacity, str._capacity);

	}
	String(const String& str)//拷贝构造底层也是调用构造
		:_size(0)//等会用来交换这些就置空
		, _capacity(0)
		, _data(nullptr)
	{
		cout << "拷贝构造" << endl;
		String tmp(str._data);//随便来个第三方变量创造出空间和内容
		Swap(tmp);//交换后tmp就为空了
	}

	~String(){
		if (_data){//一定要判断，否则释放空指针
			delete[] _data;//所有的都是new[]
		}
		_data = nullptr;//不用的最好变成空指针
		_capacity = _size = 0;

	}
	bool operator==(const String& str){//这个传一个参数返回一个bool
		if (_data == str._data&&_size == str._size&&_capacity == str._capacity)
			return true;
		return false;
	}

	//赋值运算符重载的返回值是引用提高效率,不加也可以过，
	//+法运算符写在类外，返回的是值，如果返回引用就是返回局部变量的值，返回值的话会返回匿名对象（拷贝构造）
	//利用传值调用拷贝构造，就不用新变量了
	//弊端是不能加const,cosnt修饰的不能swap
	String& operator=(String str){
		Swap(str);
		return *this;
	}

	/*String& operator=(const String& str){//形参也不能是const
		if (*this == str){
			return *this;
		}
		String tmp(str);//调用拷贝构造，拷贝构造底层是通过str的_data调用构造，不具有常性
		Swap(tmp);//可以用来交换
		return *this;
	}*/

	char& operator[](size_t a){//取下标要求可以通过下表修改所以是返回引用
		assert(a < _size);//下标越界是需要assert的警告,assert内部是正确的范围
		return _data[a];
	}

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

	void reserve(size_t ch){//增容，就是修改_capacity的大小,参数就是需要改变的大小
		if (_capacity < ch){//小于就不动
			char* newp = new char[ch + 1];//这里有个+1没写 ch表示有效字符的最大个数不包括\0

			//拷贝存数据的内容
			strcpy(newp, _data);
			delete[] _data;//释放原有内容，避免内存泄露
			_data = newp;
			_capacity = ch;
		}
	}

	void resize(size_t ch, const char& a = '\0'){//改变_size的大小，不足用指定的符号补齐
		if (_capacity < ch)//先看容量
			reserve(ch);
		if (_size < ch)
			memset(_data + _size, a, sizeof(char)*(ch - _size));//太多了才填充字符，这个可不会填充_capacity
		_size = ch;//修改size的大小
		//忘记\0
		_data[_size] = '\0';//数据一定要有结束标志
	}


	void push_back(const char&a = '\0'){
		if (_size == _capacity){//证明满了需要增容
			//三目运算符顺序
			size_t newcapacity = _capacity == 0 ? 15 : 2 * _capacity;
			reserve(newcapacity);//增容
		}
		_data[_size++] = a;//size没有存\0
		_data[_size] = '\0';
	}

	void append(const char* str){//插入新的字符数组
		if (_capacity < (strlen(str) + _size)){
			//等于甚至也不需要增容。因为reserve自动申请多一个存储\0,而_capacity隐藏这个
			//构造函数也会默认多申请一个空间用来存储\0
			reserve(strlen(str) + _size);
		}
		memcpy(_data + _size, str, sizeof(char)*strlen(str));
		//忘记更新size
		_size += strlen(str);
		_data[_size] = '\0';//注意新增
	}

	//+=需要写在类内。返回引用，提高效率,返回值需要调用一次拷贝构造
	String& operator+=(const String& str){
		cout << "operator +=" << endl;
		append(str._data);
		return *this;
	}

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

	String& operator+=(const char& str){
		push_back(str);
		return *this;
	}

	void insert(size_t pos, const char& ch){//pos的下一个位置插入
		assert(pos <= _size);//可以等于，忘写了
		//size代表的是元素个数
		if (_size == _capacity){
			size_t newc = _capacity == 0 ? 1 : 2 * _capacity;
			reserve(newc);
		}

		size_t idx = _size;
		while (idx>pos-1){//pos的位置也要移动
			_data[idx+1] = _data[idx];
			--idx;
		}
		/*size_t idx = _size + 1;//从后向前移动，包括\0
		while (idx>pos){
			_data[idx] = _data[idx - 1];
			idx--;
		}*/
		_data[pos] = ch;
		++_size;
	}

	void insert(size_t pos, const char* ch){
		assert(pos <= _size);
		size_t len = strlen(ch);
		if (len + _size > _capacity){
			reserve(len + _size);
		}
		size_t idx = _size + len;

		
		while (idx>pos+1){
			_data[idx] = _data[idx - len];
			idx--;
		}
		memcpy(_data + pos, ch, sizeof(char)*len);//不能strcpy-->会拷贝\0
		_size += len;
	}

	void earse(size_t pos, size_t len = npos){
		assert(pos <= _size);
		//如果没有指定删除的大小或者需要全部删除后面的
		if (pos + len >= _size || len == npos){
			_size = pos;
			_data[_size] = '\0';

		}
		else{
			size_t idx = pos + len;
			while (idx <= _size){
				_data[idx - len] = _data[idx];
				++idx;
			}
			_size -= len;
		}
	}

	size_t find(const char* ch, size_t pos = 0){//pos是从这个位置之后查找
		assert(pos < _size);
		char* strpos = strstr(_data + pos, ch);
		if (strpos){
			return strpos - _data;//返回找到的位置（指针相减）
		}
		return npos;
	}

	String substr(size_t pos, size_t len = npos){//创建子串
		assert(pos < _size);
		if (pos + len >= _size || len == npos){
			return String(_data + pos);//pos是一个数字，指针加数字是指针
		}
		else{
			char* newc = new char[len + 1];
			//char *newc=[len+1];栈申请需要高级编译器才能识别
			memcpy(newc, _data + pos, sizeof(char)*len);
			newc[len] = '\0';
			delete[] newc;//这里不写会内存泄漏，写了会报错
			return String(newc);
		}
	}

	size_t size()const{
		return _size;
	}

	size_t capacity()const{
		return _capacity;
	}


	const char* c_str() const{
		return _data;
	}
	friend ostream& operator<<(ostream& out, const String& str);
	friend istream& operator>>(istream& cin, String& str);
};

const size_t String::npos = -1;

//以下属于普通函数,重载函数，不能通过str.operator<<来访问
//只能通过普通函数的访问形式访问
String operator+(const String& a, const String& b){//普通函数不能加string::
	String str(a);  //拷贝构造需要const，否则报错
	//因为const可以接受const和非const，非const只能接受const
	str += b;
	return str;
}
String operator+(const String& a, const char* b){
	String str(a);
	str += b;
	return str;
}
String operator+(const String& a, const char& b){
	String str(a);
	str += b;
	return str;
}

bool operator<(const String& str1, const String& str2){
	int a = strcmp(str1.c_str(), str2.c_str());//1>2--大于0 否则小于0
	if (a<0){
		return true;
	}
	return false;
}

bool operator==(const String& str1, const String& str2){
	int a = strcmp(str1.c_str(), str2.c_str());
	if (a == 0){
		return true;
	}
	return false;
}

bool operator!=(const String& str1, const String& str2){
	return !(operator== (str1, str2));
}

//这里是借助迭代器来实现的打印，没有访问类的私有成员，不用写友元
ostream& operator<<(ostream& out, String& str){
	for (const auto ch : str){
		out << ch;
	}
	return out;
}

//相比于输出流简单地输出，输入流相当于尾插string
istream& operator>>(istream& cin, String& str){
	char ch;
	while ((ch = cin.get()) != EOF){
		if (ch == ' ' || ch == '\0')
			break;
		str += ch;
	}
	return cin;
}

void printffor(const String& str){//const是为了也同时可以打印const的字符串
	//形参const走的就是const的迭代器
	for (const char& a : str){   //const_it
		cout << a;
	}
	cout << endl;
}

void printffor2(const String& str){
	String::const_iterator it = str.begin();
	while (it != str.end()){
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

void test(){
	String str1 = "hello";
	String str2 = " world";

	
	cout << str1 << endl;
	cin >> str2;
	cout << str2 << endl;
}

int main(){
	test();
	system("pause");
	return 0;
}
zhao111222333444
关注
专栏目录
关于C++ string类的基本操作实验 <一>
skysys的研究小屋
08-10 698
首先在调用前要包含一行头文件 #include 然后包含命名空间 using namespace std; 或者 using namespace std::string; 好，让我们开始我们的实验。 首先是创建变量 string s; 我们可以在创建变量的同时对它赋值. string s = "test"; 或者我们调用构造函数对它进行创建和初始化
【C++】string类的模拟实现
m0_51064412的博客
07-29 430
文章目录一. 传统版写法的string类1. private成员2. 构造函数3. 析构函数4. 拷贝构造和赋值重载4.1 什么是浅拷贝？4.2 浅拷贝带来的问题4.3 深拷贝完成拷贝构造和赋值重载5. 完整代码 一. 传统版写法的string类 主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。 1. private成员 就是一个C语言中的字符串指针 class string { public: private: char* _str; }; 2. 构造函数 我们设计一个全缺省的
C++——模拟实现String类
陌上人如玉，公子世无双。
08-21 323
#pragma once #include<assert.h> #include <string> #include<iostream> using namespace std; namespace MyString { class String { public: typedef char* Iterator; //迭代器 Iterat...
C++模拟实现string类
Gerald的博客
03-26 321
string类 1.标准库中的string类 1.1 在http://www.cplusplus.com/reference/string/string/ 中是这样解释的： String class Strings are objects that represent sequences of characters. The standard string class provides supp...
模拟实现string类
Mr.Li的博客
01-17 638
string类的模拟实现 本文只是对部分函数进行分析和代码展示，具体代码我已经上传到GitHub上面了 GitHub链接：https://github.com/Sveter/CPlusPlus string类 string是表示字符串的字符串类 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 string在底层实际是：basic_string模板类的别...
c++模拟实现string类
北川_的博客
01-11 1876
目录string类简介模拟实现成员变量成员函数构造函数拷贝构造赋值重载析构函数迭代器普通迭代器const迭代器重载运算符[ ]代码 string类简介 标准库类型string表示可变长的字符序列，使用string类型必须首先包含string头文件。作为标准库的一部分，string定义在命名空间std中。 模拟实现 成员变量 char* _str; size_t _size; size_t _capacity; //不包含最后做标识的'\0' static const size_t npos; _s
C++ —— 模拟实现string类
weixin_59913110的博客
11-07 1550
本篇博客分享了笔者如何模拟实现string类的过程。其中包括最常用、最实用的接口。例如流插入、提取运算符重载、下标运算符重载、常用的构造函数、析构函数……
C++ 之 string类的模拟实现
最新发布
foodsx的博客
04-26 1292
C++ 之 string类的模拟实现
C++模拟实现string类的深浅拷贝解析
本文档介绍了如何模拟实现C++中的`string`类，重点讨论了深浅拷贝的概念，包括构造函数、析构函数以及拷贝构造函数的实现。提供了源代码链接供参考。 在C++中，`std::string`是一个非常常用的类，用于处理字符串。...
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中String类模拟实现以及深拷贝浅拷贝
08-28
然而，为了更好地理解这一封装的实现原理，开发者有时需要模拟实现一个String类。在这模拟实现的过程中，必须处理深拷贝（deep copy）和浅拷贝（shallow copy）的问题。 浅拷贝在对象复制时，仅仅是复制了对象的...
C++模拟实现String类：基础功能与深拷贝
"这篇文章主要介绍了如何在C++中模拟实现String类的基本功能，包括构造函数、拷贝构造函数、析构函数、赋值运算符重载、运算符`+=`的重载、运算符`[]`的重载、`c_str`方法、`Size`方法、`Push_Back`方法、`Insert`...
【C++】细节满满地lambda表达式讲解！
zhaocx111222333的博客
06-04 957
lambda格式捕捉列表说明：细节及使用作为仿函数 格式 lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement } [捕捉列表] (参数列表) 取消常量性 -> 返回值类型{函数体} lambda项目 细节说明 捕捉列表 作为lambda表达式的起始标志，可以捕捉上下文中的变量供lambda函数使用 参数列表 与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
【C++】拷贝构造函数不能传值的原因探究
zhaocx111222333的博客
03-07 561
首先,拷贝构造函数就是以一个对象作为形参的构造函数. 不能传值是因为传值的过程中,形参是实参的一份拷贝. 我们的参数是一个对象,此时编译器调用拷贝构造函数. 如果传值的话,我们在实现拷贝构造函数时需要调用拷贝构造函数复制实参,此时还未定义拷贝构造函数,就会陷入无穷递归… class Date { public: Date(int year = 2021, int month = 2, int day = 3) { _year = year; _month = month; _day .
【c++】范围for详解及注意事项
zhaocx111222333的博客
03-18 485
范围for一般使用：通过for循环对数据进行修改： C++11中引入了范围for，他有几个注意点值得关注。 一般这样写： for(auto e:obiect) cout<<e; e是用于迭代的变量. =object是一个对象，范围for实际上是通过迭代器实现的，支持迭代器访问的自定义类型才可以支持范围for循环。（比如：初始化列表，string，数组等） 一般使用： void test(){ int arr[5] = { 1, 2, 3, 4, 5 }; char arr1[6] = "
【C++】日期类的创建
zhaocx111222333的博客
03-12 391
#include<iostream> using namespace std; class Date{ public: //天数 int getDay(int year, int month){ int dayarr[13] = { 0,31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; int day = dayarr[month]; if (month == 2 && (year == 4 &amp
C++模拟实现String类基础功能详解
"C++中的String类是一个非常常用的数据结构，用于处理文本字符串。本文将探讨如何简单地实现一个基础版的String类，虽然不能与标准库中的std::string完全相同，但足以涵盖一些核心功能，如构造函数、拷贝构造函数、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值