String类的实现（C++）

最新推荐文章于 2024-08-13 08:00:00 发布
最新推荐文章于 2024-08-13 08:00:00 发布
阅读量321 收藏 4
点赞数 7
分类专栏： C++知识点 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lu_pinus/article/details/140886794
版权

声明：本文目的是为探寻string的底层原理，而不是细扣每一个函数的具体实现

1.头文件（先参考用，下面会逐个分析）

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once

#include<iostream>
#include<string>
#include<assert.h>
using namespace std;

namespace CC
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		const_iterator begin() const
		{
			return _str;
		}
		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

		size_t size() const
		{
			return _size;
		}
		size_t capacity() const
		{
			return _capacity;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);

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

			return _str[pos];
		}

		//深拷贝
		string(const string& s)
		{
			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}
		//赋值
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				delete[] _str;
				_str = new char[s._capacity + 1];
				strcpy(_str, s._str);
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}
		//现代写法(深拷贝，赋值)
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		string(const string& s)
		{
			string tmp(s._str);
			swap(tmp);
		}
		string& operator=(string tmp)
		{
			swap(tmp);
			return *this;
		}
		
		//流提取前清除
		void clear()
		{
			_str[0] = '\0';
			_size = 0;
		}
		//兼容c_str()函数
		const char* c_str() const
		{
			return _str;
		}

		void reserve(size_t n);
		void push_back(char ch);
		void append(const char* str);
		string& operator+=(char ch);
		string& operator+=(const char* str);

		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);
		void erase(size_t pos, size_t len = npos);

		size_t find(char ch, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);
		string substr(size_t pos = 0, size_t len = npos);

	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
		static const size_t npos;
	};

	bool operator<(const string& s1, const string& s2);
	bool operator<=(const string& s1, const string& s2);
	bool operator>(const string& s1, const string& s2);
	bool operator>=(const string& s1, const string& s2);
	bool operator==(const string& s1, const string& s2);
	bool operator!=(const string& s1, const string& s2);

	ostream& operator<<(ostream& out, const string& s);
    istream& operator>>(istream& in, string& s);
}

1）私有成员

char* _str = nullptr;
size_t _size = 0;//长度
size_t _capacity = 0;//容量
static const size_t npos;
//npos=-1（后面会定义），为了后面的函数使用，其实就是return -1的作用

2）迭代器实现

typedef char* iterator;//普通迭代器
typedef const char* const_iterator;//常量迭代器
iterator begin()
{
	return _str;
}
iterator end()
{
	return _str + _size;
}
const_iterator begin() const
{
	return _str;
}
const_iterator end() const
{
	return _str + _size;
}

3）构造与析构

string(const char* str = "")//初始化为"\0"
{
	_size = strlen(str);//这里用到了string.h里的函数
	_capacity = _size;
	_str = new char[_capacity + 1];//为"\0"预留空间
	strcpy(_str, str);//将后者拷贝给前者
}
~string()
{
	delete[] _str;//销毁
	_str = nullptr;//置空
	_size = _capacity = 0;
}

4）深拷贝与赋值

string(const string& s)
{
	_str = new char[s._capacity + 1];//为新地址开空间
	strcpy(_str, s._str);//依次将s的值赋给_str
	_size = s._size;
	_capacity = s._capacity;
}
string& operator=(const string& s)
{
	if (this != &s)
	{
		delete[] _str;//销毁原有空间，再用新值覆盖
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}
//这是比较质朴的写法，下面介绍一种简洁写法（效率上是没什么差别的）
void swap(string& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}
string(const string& s)
{
	string tmp(s._str);//深拷贝不能改变原有的值，所以要定义临时变量
	swap(tmp);
}
string& operator=(string tmp)//这里其实相当于把s直接拷贝给了tmp，省了一步
{
	swap(tmp);
	return *this;
}

其余头文件内容都为一些函数声明与一些底层函数（浅显易懂），不做赘述

2.源文件

#include"string.h"

namespace CC
{
	const size_t string::npos = -1;

	void string::reserve(size_t n)
	{
		if (n > _capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}
	void string::push_back(char ch)
	{
		if (_capacity == _size)
		{
			reserve(_capacity == 0 ? 4 : 2 * _capacity);
        }
		_str[_size] = ch;
		++_size;
		_str[_size] = '\0';
	}
	string& string::operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}
	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
		}
		strcpy(_str + _size, str);
		_size += len;
	}
	string& string::operator+=(const char* str)
	{
		append(str);
		return *this;
	}

	void string::insert(size_t pos, char ch)
	{
		assert(pos < _size);
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
		size_t end = _size + 1;
		while (pos < end)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = ch;
		++_size;
	}
	void string::insert(size_t pos, const char* s)
	{
		assert(pos < _size);
		size_t len = strlen(s);
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
		size_t end = _size + len;
		while (pos + len - 1 < end)
		{
			_str[end] = _str[end - len];
			--end;
		}
		for (size_t i = 0; i < len; i++)
		{
			_str[pos + i] = s[i];
		}
		_size += len;
	}
	void string::erase(size_t pos, size_t len)
	{
		assert(pos < _size);
		if (len >= _size - pos)
		{
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			for (size_t i = pos + len; i < _size; i++)
			{
				_str[i - len] = _str[i];
			}
			_size -= len;
		}
	}
	size_t string::find(char ch, size_t pos)
	{
		assert(pos < _size);
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == ch)
			{
				return i;
			}
		}
		return npos;
	}
	size_t string::find(const char* str, size_t pos)
	{
		assert(pos < _size);
		const char* ptr = strstr(_str + pos, str);
		if (ptr == nullptr)
		{
			return npos;
		}
		else
		{
			return ptr - _str;
		}
	}
	string string::substr(size_t pos, size_t len)
	{
		assert(pos < _size);
		if (len > _size - pos)
		{
			len = _size - pos;
		}
		string sub;
		sub.reserve(len);
		for (size_t i = 0; i < len; i++)
		{
			sub += _str[i + pos];
		}
		return sub;
	}

	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)
	{
		return s1 < s2 || s1 == s2;
	}
	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}
	bool operator>=(const string& s1, const string& s2)
	{
		return !(s1 < s2);
	}
	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)
	{
		return !(s1 == s2);
	}

	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}
		return out;
	}
	//istream& operator>>(istream& in, string& s)
	//{
	//	s.clear();
	//	char ch;
	//	ch = in.get();
	//	while (ch != ' ' && ch != '\0')
	//	{
	//		s += ch;
	//		ch = in.get();
	//	}
	//	return in;
	//}//此方法是从in中读取一个立即+=一个，效率较低
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		const int n = 256;
		char buff[n];
		int i = 0;
		char ch;
		ch = in.get();
		while (ch != ' ' && ch != '\0')
		{
			buff[i++] = ch;
			if (i == n - 1)
			{
				buff[n] = '\0';
				s += buff;
				i = 0;
			}
			ch = in.get();
		}
		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}//创建了一个buff[]缓冲区,当buff[]储存满了再进行拷贝
}

1）reserve（）扩容
 

void string::reserve(size_t n)
{
	char* tmp = new char[n+1];
	strcpy(tmp, _str);
	delete[] _str;
	_str = tmp;
	_capacity = n;
}

	const size_t string::npos = -1;//充当一个返回值

2）push_back()尾插 与 operator+=()

void string::push_back(char ch)//插入的是单个字符
{
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}
	_str[_size] = ch;
	_size++;
	_str[_size] = '\0';
}
string& string::operator+=(char ch)
{
	push_back(ch);
	return *this;
}

3）append（）尾插一个字符串 与 operator+=()

void string::append(const char* str)
{
	size_t len = strlen(str);
	if (len + _size > _capacity)
	{
		reserve(len + _size > 2 * _capacity ? _size + len : 2 * _capacity);
	}
	strcpy(_str + _size, str);
	_size += len;
}
string& string::operator+=(const char* str)
{
	append(str);
	return *this;
}

4）insert（）

void string::insert(size_t pos, char ch)
{
	assert(pos < _size);
	reserve(_capacity == 0 ? 4 : 2 * _capacity);
	size_t end = _size + 1;
	while (pos < end)
	{
		_str[end] = _str[end - 1];
		end--;
	}
	_str[pos] = ch;
	_size++;
}
void string::insert(size_t pos, const char* s)
{
	assert(pos < _size);
	size_t len = strlen(s);
	reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
	size_t end = _size + len;
	while (pos + len - 1 < end)//不要忘-1
	{
		_str[end] = _str[end - len];
		--end;
	}
	for (size_t i = 0; i < len; i++)
	{
		_str[pos + i] = s[i];
	}
	_size += len;
}

  1. 这里不建议用strcpy（）直接拷贝

  2. 使用for循环可以确保插入的字符串中如果包含了空字符('\0')，也能正确地复制到字符串中。而strcpy()函数会在遇到空字符时停止复制，可能会导致插入的字符串不完整。因此，为了保证插入的字符串完整地复制到目标位置，需要使用for循环逐个字符复制

Lu_pinus
关注
专栏目录
String类实现的头文件
12-15
String 运算符重载等实现c++类与String类定义的串之间的运算
典型的String类实现C++
11-22
一个典型的String类实现，C++描述，里面包括String的构造函数，赋值构造函数，析构函数，赋值操作符的实现等
C++中string的常用函数总结
热门推荐
woxiaozhi的专栏
02-28 1万+
标准c++中string类函数介绍 注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据
C++——string 类
最新发布
2301_80636070的博客
08-13 1149
在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；3)用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。4)auto不能作为函数的参数，可以做返回值，但是建议谨慎使用。
string头文件常用方法（C++）
努力搬砖的打工人
01-23 1万+
string 定义字符串，如果未赋初值，则默认是 "" ，即空字符串，结尾也没有结束标志 \0 #include <string> using namespace std; int main() { string s1; // 空字符串 string s2(5, 's'); // s2 = "sssss"; } 常用成员函数： 求字符串长度 str.length(); 字符串的拼接，可以用 + 或者 += 直接拼接字符串 用 + 拼接字符串时，可以两边都是 string字符串；
C++ string头文件
ruiyao_369的博客
10-25 1046
函数 stod(const string& str, size_t* idx = 0)； stof (const string& str, size_t* idx = 0); stoi (const string& str, size_t* idx = 0, int base = 10); stol (const string& str, size_t* ...
c++ string头文件
Android framework
02-06 828
c++ string头文件
详解C++的String类的字符串分割实现
01-20
在C++编程语言中，与Java不同，标准库并没有提供内置的String类的`split`方法来方便地进行字符串分割。然而，这并不意味着我们不能实现类似的功能。当我们需要将一个字符串按照特定的分隔符切割成多个子字符串时，...
C++简单String类的实现
12-22
我跟很多童鞋一样，目前也在学习C++中，昨天正在学习has-a关系中的包含时，例题是将string类包含的，因为是小白嘛，嘿嘿，为了更深的理解包含以及其他相关问题，果断上机边敲代码边理解咯，既然用到了string类，自己...
C++中String类的实现
12-22
String是C++中的重要类型，程序员在C++面试中经常会遇到关于String的细节问题，甚至要求当场实现这个类。只是由于时间关系，可能只要求实现构造函数、析构函数、拷贝构造函数等关键部分。 　String的实现涉及很多...
C++ String头文件详解
化身孤岛的鲸o的博客
01-30 3425
对于一些喜欢用c++编程或者做题的人来说，字符串string是经常要用到的。所以我们要了解其中的一些函数以及使用方法 清单一，声明： （1）string s                          ...
与string相关的头文件解析（C/C++）
手边笔记
12-13 3533
与string相关的头文件解析（C/C++） 1.下面是大家比较熟悉的头文件#include c++标准库提供的string类 #include c标准库提供的字符串函数 #include c++对标准c字符串处理函数的c++增强string中定义的是一个string类，不用说什么了，但是string.h 和 cstring有什么呢？ /* * This is the C++
C++中的＜string＞头文件 和 ＜cstring＞头文件简介
cnds123的专栏
09-10 7352
C++中的头文件 和 头文件简介
C++之string
iwkxi的博客
06-03 3091
我等必将复起，古木已发新枝。
c++ string 头文件_C 标准<stdlib.h>
weixin_30707165的博客
12-29 343
C 标准库 <stdlib.h>学习环境搭建1_Linux C语言_嵌入式开发工程师-创客学院​www.makeru.com.cn数据类型_Linux C语言_嵌入式开发工程师-创客学院​www.makeru.com.cn简介stdlib .h 头文件定义了四个变量类型、一些宏和各种通用工具函数。库变量下面是头文件 stdlib.h 中定义的变量类型：序号变量 & 描述1siz...
3.31C++中string头文件
ugly_g的博客
03-31 323
·说明C++中string头文件中部分函数应用 #include <string> using namespace std; 1.构造函数(Constructors) 语法: string(); string( size_type length, char ch ); string( const char *str ); ...
C++中使用string引用头文件
Zohar的博客
10-09 3329
using namespace std; #include
C++ <string>标准头文件
chenglai5522的博客
10-02 137
转载于:https://my.oschina.net/imtoby/blog/81327
C++自定义String类详解与实现
7. **实践意义**: 自己实现C++ String类是学习C++语言的重要一步，通过这样的项目，开发者可以加深对类设计、内存管理、引用计数等概念的理解，从而提高编程能力和解决问题的能力。 这个文档提供了一个动手实现C++ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值