C++ string类的模拟实现

已于 2022-07-03 16:08:13 修改
阅读量493 收藏
点赞数 1
分类专栏： C++初阶 文章标签： c++ c语言
于 2022-04-12 20:48:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61548909/article/details/124133859
版权

 目录

 1.string类的结构定义

2.string类迭代器的实现

3.string类的构造，析构，拷贝构造，赋值运算符重载

3.1构造函数

3.2析构函数

3.3拷贝构造函数

3.4赋值运算符重载

4管理字符串的数组，可以增删查改

4.1reverse()接口

4.2resize()接口

4.3push_back接口

4.4append()接口

4.5insert()接口

4.6erase()接口

4.7find()接口

4.8clear()接口

4.9getline()接口

4.10size()接口

4.11c_str()接口

5.运算符重载

5.1[]

5.2==

5.3+=

5.4<

5.5<=

5.6>

 5.7>=

5.8!=

5.9<<

5.10>>

6.补充题目（替换字符串中的空格）

namespace bit
{
	class string
	{
	public:
		typedef char* iterator;
	public:
		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& operator=(string s)
		{
			this->Swap(s)
				return *this;
		}
		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}
		/
		// iterator
		iterator begin() { return _str; }
		iterator end() { return _str + _size; }
		/
		// modify
		void push_back(char c)
		{
			if (_size == _capacity)
				Reserve(_capacity * 2);

			_str[_size++] = c;
			_str[_size] = '\0';
		}
		string& operator+=(char c)
		{
			PushBack(c);
			return *this;
		}

		// 作业实现
		void append(const char* str);
		string& operator+=(const char* str);
		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}
		void swap(string& s)
		{
			swap(_str, s._str);
			swap(_size, s._size);
			swap(_capacity, s._capacity);
		}
		const char* c_str()const
		{
			return _str;
		}
		/
		// capacity
		size_t size()const
			size_t capacity()const
			bool empty()const

			void resize(size_t newSize, char c = '\0')
		{
			if (newSize > _size)
			{
				// 如果newSize大于底层空间大小，则需要重新开辟空间
				if (newSize > _capacity)
				{
					Reserve(newSize);
				}
				memset(_str + _size, c, newSize - _size);
			}
			_size = newSize;
			_str[newSize] = '\0';
		}
		void reserve(size_t newCapacity)
		{
			// 如果新容量大于旧容量，则开辟空间
			if (newCapacity > _capacity)
			{
				char* str = new char[newCapacity + 1];
				strcpy(str, _str);
				// 释放原来旧空间,然后使用新空间
				delete[] _str;
				_str = str;
				_capacity = newCapacity;
			}
		}
		
		// access
		char& operator[](size_t index)
		{
			assert(index < _size);
			return _str[index];
		}
		const char& operator[](size_t index)const
		{
			assert(index < _size);
			return _str[index];
		}
		
		// 作业
		bool operator<(const string& s);
		bool operator<=(const string& s);
		bool operator>(const string& s);
		bool operator>=(const string& s);
		bool operator==(const string& s);
		bool operator!=(const string& s);
		// 返回c在string中第一次出现的位置
		size_t find(char c, size_t pos = 0) const;
		// 返回子串s在string中第一次出现的位置
		size_t find(const char* s, size_t pos = 0) const;

		// 在pos位置上插入字符c/字符串str，并返回该字符的位置
		string& insert(size_t pos, char c);
		string& insert(size_t pos, const char* str);
		// 删除pos位置上的元素，并返回该元素的下一个位置
		string& erase(size_t pos, size_t len);
 private:
	 friend ostream& operator<<(ostream& _cout, const bit::string& s);
	 friend istream& operator>>(istream& _cin, bit::string& s);
 private:
	 char* _str;
	 size_t _capacity;
	 size_t _size;
 };
}
ostream& bit::operator<<(ostream& _cout, const bit::string& s) {
	// 不能使用这个
	//cout << s._str;
	for (size_t i = 0; i < s.size(); ++i)
	{
		_cout << s[i];
	}
	return _cout;
}
///对自定义的string类进行测试
void TestBitstring()
{
	bit::string s1("hello");
	s1.push_back(' ');
	s1.push_back('b');
	s1.append(1, 'i');
	s1 += 't';
	cout << s1 << endl;
	cout << s1.size() << endl;
	cout << s1.capacity() << endl;
	// 利用迭代器打印string中的元素
	string::iterator it = s1.begin();
	while (it != s1.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 这里可以看到一个类只要支持的基本的iterator，就支持范围for
	for (auto ch : s1)
		cout << ch << " ";
	cout << endl;
}

 1.string类的结构定义

 class string
{
public:

private:
	char* _str;

	size_t _size;
	size_t _capacity;

	static const size_t npos;
};

 其中nops就是无符号整型中的-1

2.string类迭代器的实现

 image-20220213131213547

class string
{
public:
    typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		const_iterator begin() const
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

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

3.string类的构造，析构，拷贝构造，赋值运算符重载

 

class string
	{

	public:
		string(const char* str = "")
			: _str(new char[strlen(str) + 1])
		{
			strcpy(_str, str);

		}

		//传统写法
		string(const string& s)
			:_str(new char[strlen(s._str)+1])
		{
			strcpy(_str, s._str);
		}

		//赋值重载
		//s1 = s3
		//s1 = s1
		string& operator = (const string& s)
		{
			if (this != &s)//此处this是s1的地址,防止自己和自己赋值
			{
				delete[]_str; 
					_str = new char[strlen(s._str) + 1];
				strcpy(_str, s._str);
			}
			return *this;
		}



		//现代写法
		//s2(s1)
		string(const string& s)
			:_str(nullptr)
		{
			string tmp(s._str);
			swap(_str,tmp._str);

		}

		   //赋值
		//自己和自己赋值时存在缺陷
		string& operator=(string s)
		{
			swap(_str, s._str);
			return *this;
		}
		/*string& operator = (contst string& s)
		{
			if (this != &s)
			{
				string tmp(s);
				swap(_str, tmp_str);
				return *this;
			}
		}*/

		~string()
		{
			delete[]_str;
			_str = nullptr;
			
		}
		const char* c_str()
		{
			return _str;
		}

3.1构造函数

string(const char* str = "")
{
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];//给_str一个strlen(s)+1长度的空间

	strcpy(_str, str);//拷贝
}

3.2析构函数

 ~string()
{
	delete[] _str;
	_str = nullptr;
	_size = 0;
	_capacity = 0;
}

3.3拷贝构造函数

swap函数的写法与改进

 

// s1.swap(s2);
void swap(string& s)
{
    //交换_s和tmp._s,就相当于给this->_s开辟了一块空间,当拷贝函数结束,tmp就会被自动释放
	::swap(_str, s._str);
	::swap(_size, s._size);
	::swap(_capacity, s._capacity);
}

//传统写法
//s2(s1)
string(const string& s)
	:_str(new char[strlen(s._str)+1])
{
	strcpy(_str, s._str);
}


// s2(s1)  现代写法
string(const string& s)
	:_str(nullptr)//必须置空,因为_str开始是个随机数,交换给tmp._str后,释放会引起问题
	, _size(0)
	, _capacity(0)
{
	string tmp(s._str);//直接利用构造函数,给tmp对象开辟了一块空间
            /*swap(_str,tmp._str);
			swap(_size, tmp._size);
			swap(_capacity, tmp._capacity);*/

	//this->swap(tmp);
	swap(tmp);
}

3.4赋值运算符重载

存在传统和现代两种写法

// s1 = s3 传统写法
string& operator=(const string& s)
{
	if (this != &s) // s1 = s1//此处this是s1的地址,防止自己和自己赋值
	{
		delete[] _str;
		_str = new char[strlen(s._str) + 1];
		strcpy(_str, s._str);
	}

	return *this;
}

// s1 = s3 现代写法
string& operator=(string s)
{
            /*swap(_str, s._str);
			swap(_size, s._size);
			swap(_capacity, s._capacity);*/
	swap(s);//swap前面已写出

	return *this;
}
/*string& operator = (contst string& s)
		{
			if (this != &s)
			{
				string tmp(s);
				swap(_str, tmp_str);
				return *this;
			}
		}*/

4管理字符串的数组，可以增删查改

4.1reverse()接口

// 开空间，扩展capacity
void reserve(size_t n)
{
	if (n > _capacity)
	{
		char* tmp = new char[n + 1];//这里必须要多开一个空间存储\0
		strncpy(tmp, _str, _size + 1);//多开的那个空间存储位置
		delete[] _str;

		_str = tmp;
		_capacity = n;
	}
}

4.2resize()接口

resize( ) 分为三种情况

  • 当n小于size,则size等于n.
  • 当n>size但是小于capacity时,size仍等于n,但是这个时候即使你传入另一个参数ch,也没有用
  • 当n大于size时候,会增容,然后多出的空间会用ch初始化,ch如果不传,就是\0,最后size等于n

// 开空间+初始化，扩展capacity 并且初始化空间。size也要动
void resize(size_t n, char val = '\0')
{
	if (n < _size)
	{
		_size = n;
		_str[_size] = '\0';
	}
	else
	{
		if (n > _capacity)
		{
			reserve(n);
		}

		for (size_t i = _size; i < n; ++i)
		{
			_str[i] = val;
		}
		_str[n] = '\0';
		_size = n;
	}
}

4.3push_back接口

push_back()针对的是字符

void push_back(char ch)
{
	if (_size == _capacity)
	{
        //这一步是为了防止_capacity如果为0,开不了空间
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size] = ch;
	_str[_size + 1] = '\0';//给字符串末尾加\0
	++_size;

	//insert(_size, ch);  //或者直接调用insert()
}

4.4append()接口

void append(const char* str)
{
	/*size_t len = _size + strlen(str);
	if (len > _capacity)
	{
		reserve(len);
	}

	strcpy(_str + _size, str);
	_size = len;*/

	//insert(_size, str);
}

4.5insert()接口

 插入字符

插入字符串 

//插入字符
string& insert(size_t pos, char ch)
{
	assert(pos <= _size);
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	// 类型强制转换成int，使用size_t的话，就永远走不出循环了（因为无符号整型的-1）
	/*int end = _size;
	while (end >= (int)pos)
	{
		_str[end + 1] = _str[end];
		--end;
	}*/


//或者还可以用指针
			/*size_t end = _size+1;
			while (end > pos)
			{
				_str[end] = _str[end-1];
				--end;
			}*/

	char* end = _str + _size;
	while (end >= _str + pos)
	{
		*(end + 1) = *end;
		--end;
	}

	_str[pos] = ch;
	_size++;

	return *this;
}

//在pos位置之前插入字符串
string& insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);
	}

	// 挪动数据
	char* end = _str + _size;
	while (end >= _str + pos)
	{
		*(end + len) = *end;
		--end;
	}

	strncpy(_str + pos, str, len);
	_size += len;

	return *this;
}

 

4.6erase()接口

从pos位置开始删除len个,如果len不写，末尾删除pos后的全部

string& erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	size_t leftLen = _size - pos;
	// 1、剩余的字符长度小于要删的长度  （后面全部删完）
	// 2、剩余的字符长度大于要删的长度
	if (len >= leftLen)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}

	return *this;
}

4.7find()接口

size_t find(char ch, size_t pos = 0)
{
	assert(pos < _size);

	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)
{
	assert(pos < _size);

	const char* ret = strstr(_str + pos, str);
	if (ret)
	{
		return ret - _str;
	}
	else
	{
		return npos;
	}
}

4.8clear()接口

void clear()
{
	_size = 0;
	_str[0] = '\0';
}

4.9getline()接口

istream& getline(istream& in, string& s)
{
	s.clear();

	char ch;
	ch = in.get();
	while (ch != '\n')
	{
		s += ch;
		ch = in.get();
	}

	return in;
}

4.10size()接口

size_t size() const//使用size接口，用于遍历
{
	return _size;
}

4.11c_str()接口

const char* c_str() const
{
	return _str;
}

5.运算符重载

5.1[]

分为支持两个重载，支持读和写，只支持读

// 读
const char& operator[](size_t i) const
{
	assert(i < _size);

	return _str[i];
}

// 可读，可写
char& operator[](size_t i)
{
	assert(i < _size);

	return _str[i];
}

5.2==

inline bool operator==(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) == 0;
}

5.3+=

// s1 += 'x'  针对字符
string& operator+=(char ch)
{
	push_back(ch);
	return *this;
}

// s1 += "xxxxx" 针对字符串
string& operator+=(const char* str)
{
	append(str);
	return *this;
}

5.4<

inline bool operator<(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) < 0;
}

5.5<=

inline bool operator<=(const string& s1, const string& s2)
{
	return s1 < s2 || s1 == s2;
}

5.6>

 inline bool operator>(const string& s1, const string& s2)
{
	return !(s1 <= s2);
}

 5.7>=

inline bool operator>=(const string& s1, const string& s2)
{
	return !(s1 < s2);
}

5.8!=

inline bool operator!=(const string& s1, const string& s2)
{
	return !(s1 == s2);
}

5.9<<

ostream& operator<<(ostream& out, const string& s)
{
	for (auto ch : s)
	{
		out << ch;
	}

	return out;
}

5.10>>

istream& operator>>(istream& in, string& s)
{
	s.clear();

	char ch;
	ch = in.get();
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		ch = in.get();
	}

	return in;
}

6.补充题目（替换字符串中的空格）

ScarboroughFair#
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++面试题之模拟实现string类
TerryZjl的博客
03-27 1165
C++中的string类是一个很常见的面试题，string类里必须有的构造函数，拷贝构造，赋值运算符重载，析构函数等成员函数，下面看看是如何实现以及如何处理动态内存 写时拷贝技术是通过"引用计数"实现的，因为浅拷贝的缺陷，所以在这个时候我们就引入了引用计数的拷贝。但是当其中一个对象改变它的值时，其他对象的值就会随之改变，所以此时我们采取这样一种做法，就是写时拷贝。写时拷贝指用浅拷贝的方法拷贝其他对象，多个指针指向同一块空间，只有当对其中一个对象修改时，才会开辟一个新的空间给这个对象，和它原来指向同一空间
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
C++ —模拟实现 string类
芮萌萌的博客
07-26 371
String类：标准库类型string类表示可变长的字符序列，定义在std中，专门用来管理字符串，下面一起看下它的重要考点。 一：浅拷贝： class String { public: String(const char* pStr = &quot;&quot;)//构造函数 :_pStr(new char[strlen(pStr)+1]) { if(0 == *...
C++ 模拟实现string类
weixin_45307258的博客
05-21 127
C++ 模拟实现string类 String类：按照类的方式进行动态管理字符串 底层：是一种顺序表的结构，元素是char类型的字符 #include <iostream> #include <assert.h> #include <string.h> using namespace std; class String //与标准库中的string类区分S采用大写 { public: typedef char* Iterator; public: //
C++模拟实现string类
persistence_Y的博客
11-21 154
#pragma once #define _CRT_SECURE_NO_WARNINGS #include <string.h> #include <stdlib.h> #include <iostream> using namespace std; #define DEFAULTCAPA 16 #define COUNTCAPA(size) (((siz...
C++中string的模拟实现
09-01
k() 函数是将字符添加到字符串末尾。在 C++ 的标准库中，`std::string` ...在实际编程中，标准库提供的 `std::string` 类通常更为高效和安全，但在学习和理解 C++ 的面向对象编程时，这样的模拟实现是非常有价值的。
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
C++实现string类
01-08
用c++实现string类，包运算符重载+，+=，<,>，<=等，还有运算符输入输出流
【C++】模拟实现String类
Cheng_913的博客
11-05 296
     String类时C++中非常重要的一个类，模拟实现String类涉及到浅拷贝，深拷贝的问题。浅拷贝：在拷贝的时候，只是拷贝了指针的内容，而指针所指向的空间并没有变，两个指针指向同一块内存空间。在释放空间的时候，就会造成重复释放同一块内存空间而报错。深拷贝：在拷贝的时候，开辟一块和原指针指向的空间相同大小的空间，使新增加的指针指向新的内存，这样在释放空间时，就不会出现重复释放了。引用计数：...
【C++】string类模拟实现
qq_66314292的博客
09-16 1657
string类的模拟实现
【C++】String类模拟实现
weixin_43550839的博客
10-13 207
此程序为string类模拟实现，提供了深拷贝方式的拷贝构造函数+赋值运算符重载。 具体深浅拷贝的不同之处与实现方式，在下一篇博客。 #include<iostream> #include<string> using namespace std; #include<string.h> //构造+拷贝构造+析构+=重载。 namespace bite { clas...
【C++】string类的模拟实现
weixin_60478154的博客
11-16 1068
C++——string类的模拟实现
c++模拟动态语言中string类的实现
sx1989827的专栏
12-25 887
      今天闲来无事，想起动态语言里string的实现，自己也想用c++模拟下，于是便有了下文，写的过程中发现命名空间竟然不支持friend友元的使用，真郁闷，看来vc对c++标准支持的是蛮垃圾的。#include#include#include//using namespace std;class v_string{public: v_string(); v_string(char*
c++模拟实现string类
北川_的博客
01-11 1464
目录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的模拟实现
qq_52145272的博客
03-04 596
C++string的模拟实现
C++ string模拟实现
qq_58724706的博客
03-20 1566
string简易版模拟实现 我们先不直接实现完整版的string，先实现简易版的string来基本了解下它的框架，以及来学习深浅拷贝的问题。这样有循序渐进的过程嘛~ 我们首先定义一个cyq的命名空间，把我们自己实现的string写在里面，防止命名冲突。 成员变量 private: char* _str; string(const char* str = "") //构造函数 string(const char* str ...
c++string类的模拟实现
最新发布
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值