String类的实现

最新推荐文章于 2024-08-08 17:47:02 发布
最新推荐文章于 2024-08-08 17:47:02 发布
阅读量616 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 蓝桥杯 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qeqe1212/article/details/124542679
版权

目录

.h文件

.cpp文件

.h文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <assert.h>
#include <string.h>
using std::ostream;
using std::istream;
namespace stringss
{
class string{
	friend ostream& operator<<(ostream& _cout, const stringss::string& s);
	friend istream& operator>>(istream& _cin, stringss::string& s);
public:
		typedef char* iterator;
		string(const char* str = "");
		string(const string& s);
		string& operator=(const string& s);
		~string();

		// iterator
		iterator begin();
		iterator end();
		// modify

		void push_back(char c);
		string& operator+=(char c);
		void append(const char* str);
		string& operator+=(const char* str);
		void clear();
		void swap(string& s);
		const char* c_str()const;

		// capacity

		size_t size()const;
		size_t capacity()const;
		bool empty()const;
		void resize(size_t n, char c = '\0');
		void reserve(size_t n);

		// access

		char& operator[](size_t index);
		const char& operator[](size_t index)const;
		// 返回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 = -1);
private:
	char* _str;
	size_t _size;
	size_t _capacity;
	};
	//relational operators
	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);
};

.cpp文件

#include "stringss.h"
namespace stringss {

	//构造函数
	string::string(const char* str)
		:_size(strlen(str))
		, _capacity(_size)
	{
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}

	//拷贝构造函数
	string::string(const string& s)
		:_str(nullptr)
		, _size(0)
		, _capacity(_size)
	{
		string temp(s._str);
		swap(temp);
	}
	//重载=函数 与拷贝构造不同的是，这个函数不是构造函数，例如s1 = s2,s1是已经存在的。
	string& string::operator=(const string& s) {
		string temp(s);
		swap(temp);
		return *this;
	}
	//析构函数
	string::~string() {
		delete[] _str;
		_size = 0;
		_capacity = 0;
	}
	//迭代器
	string::iterator string::begin() {
		return _str;
	}
	string::iterator string::end() {
		return _str + _size;
	}
	//modify
	void string::push_back(char c) {
		insert(_size - 1, c);
	}
	string& string::operator+=(char c) {
		push_back(c);
		return *this;
	}
	void string::append(const char* str) {
		insert(_size - 1, str);
	}
	string& string::operator+=(const char* str) {
		append(str);
		return *this;
	}
	void string::swap(string& s) {
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}
	const char* string::c_str()const {
		return _str;
	}
	//capacity
	size_t string::size()const {
		return _size;
	}
	size_t string::capacity()const {
		return _capacity;
	}
	bool string::empty()const {
		return _size == 0;
	}
	void string::resize(size_t n, char c) {
		if (n < _size) {
			memset(_str, c, n);
		}
		else {
			if (n > _capacity) {
				reserve(n);
			}
			memset(_str, c, n);
			_size = n;
			_str[_size] = '\0';
		}
	}
	void string::reserve(size_t n) {
		if (n > _capacity) {
			char* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}
	//access
	char& string::operator[](size_t index) {
		assert(index < _size);
		return _str[index];
	}
	const 	char& string::operator[](size_t index)const {
		assert(index < _size);
		return _str[index];
	}
	//relational operators
	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 || 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);
	}
	// 返回c在string中第一次出现的位置

	size_t string::find(char c, size_t pos)const {
		assert(pos < _size);
		while (pos < _size) {
			if (_str[pos] == c) {
				return pos;
			}
			pos++;
		}
		return -1;
	}

	// 返回子串s在string中第一次出现的位置
	size_t string::find(const  char* s, size_t pos)const {
		assert(pos < _size);
		size_t index = pos;
		size_t start = pos;
		while (index < _size) {
			if (_str[index] == s[0]) {
				start = index;
				size_t i = 0;
				while (start < _size && i < strlen(s)) {
					if (_str[index] == s[i]) {
						start++;
						i++;
					}
					else {
						break;
					}
				}
				if (i == strlen(s)) {
					return index;
				}
			}
			index++;
		}
		return -1;
	}
	// 在pos位置上插入字符c/字符串str，并返回该字符的位置
	string& string::insert(size_t pos, char c){
		assert(pos <= _size);
		if (_size == _capacity){
			reserve(_capacity == 0 ? 4 : 2 * _capacity);
		}
		size_t end = _size + 1;//防止下标越界
		while (end > pos + 1){
			_str[end] = _str[end - 1];
			end--;
		}
		_str[end] = c;
		_size++;
		return *this;
	}

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

	// 删除pos位置上的元素，并返回该元素的下一个位置
	string& string::erase(size_t pos, size_t len){
		assert(pos < _size);
		if (len == -1 || len + pos >= _size){
			_str[pos] = '\0';
			_size = pos;
		}
		else{
			for (int i = pos + len; i <= _size; i++)
			{
				_str[i - len] = _str[i];
			}
		}
		_size -= len;
		return *this;
	}
	ostream& operator<<(ostream& _cout, const stringss::string& s){
		for (size_t i = 0; i < s._size; i++){
			_cout << s[i];
		}
		return _cout;
	}

	istream& operator>>(istream& _cin, stringss::string& s){
		s.clear();
		char ch = _cin.get();
		while (ch != ' ' && ch != '\n'){
			s += ch;
			ch = _cin.get();
		}
		return _cin;
	}
};

不知名的新手
关注
专栏目录
C++ String类的简单实现
m0_57234892的博客
03-08 2692
在之前c语言的学习中，对于字符串我们很难像整型和其他变量那样进行比较和直接的复制或者定义去运用。但在C++中为了解决这个问题提供了一种类，String类，以类型的形式对字符串进行封装，它除了作为储存字符的容器外，可以对字序列的一系列操作。 下面我们对String类进行简单的模拟实现： namespace wjx { class string { public: private: char* _str; }; 首先，我们定义一个自己的命名空间，来实现我们的string类，定义初...
String类实现的头文件
12-15
String 运算符重载等实现c++类与String类定义的串之间的运算
c++string类的实现
11-23
1)代码注释很详细的，非常适合学习STL的 2）string类经常用到find find_first_of find_first_not_of find_last_of find_last_not_of substr replace等，以及联合使用来达到java中的split和trim 3) 有些函数返回的是MyString& 、Char& 等(引用)，MyString、Char 等（传值）这得看你返回的对象是函数的局部变量还是全局变量（或者类当前对象成员变量）；前者只能返回一个MyString、Char 等；后者强烈建议返回MyString& 、Char& 等(引用)；
模拟实现string类
qq_54178958的博客
04-12 347
模拟实现string，包含增删查改等功能。 mystring.h #pragma once #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <assert.h> #include <string.h> using std::ostream; using std::istream; namespace bit { class string { friend ostream&
初识C++|string类的使用及模拟实现
最新发布
mooridy的博客
08-08 365
string原型最基本的string类由于编码方式不同，又衍生出不同的string类由此可见，string是一个模板string类——管理字符串的类，是用字符的顺序表实现的在使用string类时，必须包含以及;注意不是！
c++ string类实现
热门推荐
辉仔 の专栏
04-22 1万+
#include #include #include #include using namespace std; class CMyString { friend std::ostream& operator<<( std::ostream& os, const CMyString& str); private: char* m_
String类实现的代码
03-12
String类实现的代码,完整实现一个string的编写,希望有帮助
典型的String类实现C++
11-22
一个典型的String类实现，C++描述，里面包括String的构造函数，赋值构造函数，析构函数，赋值操作符的实现等
C++ String类实现
10-17
C++实现的String类，可以支持UTF-8编码
string类的实现
m0_72532428的博客
10-02 1157
string类构造函数的实现 1.构造函数的实现 使用**“”**空字符串作为缺省参数，常量字符串末尾有‘\0’，当不传参时，_str只存着一个‘\0’ 拷贝构造函数的实现 这里的tmp变量属于局部变量，当拷贝构造函数调用完以后栈帧会销毁，tmp变量也会跟着销毁了。 注意：同一个类域中，类的成员变量可以相互访问 string类c_str函数实现 返回字符串指针（该字符串的首地址） string类size函数的实现 _size为私有成员变量，在类域外需要通过函数才能调用进行间接访问 string类cap
实现String类
qq_36553387的博客
04-26 248
#include <iostream> #include <string> using namespace std; class String { public: String(const char* str = nullptr); //构造函数 String(const String& str); //拷贝构造 ~String(); String& operator=(const String& str);
c++string类实现难点
11-29
C++中的string类实现难点包括以下几个方面： 1. 内存管理：string类需要动态分配内存来存储字符串，因此需要实现内存管理机制，包括内存分配、释放、扩容等操作。 2. 拷贝构造和赋值运算符重载：string类需要实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值