C++:string的模拟实现

最新推荐文章于 2024-06-23 09:52:46 发布
最新推荐文章于 2024-06-23 09:52:46 发布
阅读量366 收藏 9
点赞数 11
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68421285/article/details/136373376
版权

目录

一、string类的声明

 二、string类的四个重要默认成员函数

2.1构造函数

2.2拷贝构造函数 

 2.3赋值运算符重载

 2.4析构函数

2.5现代写法 

三、string类的容量操作接口

 四、string类的修改操作接口

4.1在字符串末尾追加内容的接口

4.2插入字符的重载函数

4.3查找字符的接口 

4.4删除字符的接口 

五、string类的迭代器

六、string类中[]成员重载 

七 、string类中字符串比较运算符重载

八 、string类中流插入和流提取运算符重载

九、完整代码 

一、string类的声明

#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include<assert.h>
#include<iostream>

using namespace std;

namespace bit

{

    class string

    {
    public:
        friend ostream& operator<<(ostream& cout, const string& s);
        friend istream& operator>>(istream& cin, string& s);

        typedef char* iterator;
        typedef const char* const_iterator;
    public:

        string(const char* str = "");

        string(const string& s);

        string& operator=(const string& s);

        ~string();

        // iterator

        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        const_iterator begin() const
        {
            return _str;
        }
        const_iterator end() const
        {
            return _str + _size;
        }
        // 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 newSize, char c = '\0');
        void reserve(size_t newCapacity);
        // access
        char& operator[](size_t index);
        const char& operator[](size_t index)const;
        //relational operators
        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:
        char* _str;
        size_t _capacity;
        size_t _size;
        const  static size_t npos = -1;
    };
}

 二、string类的四个重要默认成员函数

2.1构造函数
string::string(const char* str)
{
	_size = strlen(str);
	_capacity = _size;
	_str = new char[_capacity + 1];//这里加一是为了存储'\0'但是并不计入有效字符
	strcpy(_str, str);
}

 在类外声明需要注意类域和命名空间！因为在声明中已经给过了缺省参数（const char* str=""）（常量字符串默认有'\0'结束）它确保类可以调用无参构造。同时缺省值只能在类的定义和声明中的一处给。

2.2拷贝构造函数 
string::string(const string& s)
{
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str);
	_capacity = s._capacity;
	_size = s._size;
}
 2.3赋值运算符重载
string& string::operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp, s._str);
		delete[] _str;
		_str = tmp;
		_capacity = s._capacity;
		_size = s._size;
	}
	return *this;
}
 2.4析构函数
string::~string()
{
	delete[] _str;
	_str = nullptr;
	_capacity = 0;
	_size = 0;
}
2.5现代写法 
void string::swap(string& s)
{
    std::swap(_str,s._str);
    std::swap(_size,s._size);
    std::swap(_capacity,s._capacity);
}
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)
{
    string tmp(s._str);//构造
    swap(tmp);
}
string& string::operator=(string s)//传值调用拷贝构造
{
    swap(s);
    return *this;  
}

三、string类的容量操作接口

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 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 string::reserve(size_t newCapacity)
{
     // 如果新容量大于旧容量，则开辟空间
     if (newCapacity > _capacity)
      {
          char* str = new char[newCapacity + 1];
          strcpy(str, _str);
          // 释放原来旧空间,然后使用新空间
          delete[] _str;
          _str = str;
           _capacity = newCapacity;
       }
}

 四、string类的修改操作接口

4.1在字符串末尾追加内容的接口
//尾插一个字符
void string::push_back(char ch)
{
	if (_size == _capacity)
	{
		size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
		reserve(newCapacity);//调用扩容接口
	}
	_str[_size] = ch;
	_size++;
	_str[_size] = '\0';
}
//在末尾追加一个字符串
void string::append(const char* str)
{
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);//调用扩容接口
	}
	strcpy(_str + _size, str);
	_size += len;
}

之后通过复用实现+=在字符串末尾追加字符或字符串. 

string& string::operator+=(char ch)
{
	push_back(ch);//复用push_back
	return *this;
}
string& string::operator+=(const char* str)
{
	append(str);//复用append
	return *this;
}
4.2插入字符的重载函数
//在指定位置插入一个字符
string& string::insert(size_t pos, char c)
{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newCapacity);
		}
		size_t end = _size + 1;
		while (end>pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = c;
		_size++;

		return *this;
}
//在指定位置插入一个字符串
string& string::insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	if (_size + len > _capacity)
	{
		reserve(_size + len);//扩容
	}
    //移动数据
	int end = _size;
	while (end >=(int)pos)//pos为无符号整型,所以end会减到-1,而-1的补码全是1, 因此会陷入死循环                     
	{
		_str[end + len] = _str[end];
		--end;
	}
	strncpy(_str + pos, str, len);
	_size += len;
	return *this;
}
4.3查找字符的接口 
//从下标位置开始查找字符c出现的位置
size_t string::find(char c, size_t pos) const
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == c)
			{
				return pos;
			}	
		}
		return npos;
	}
//从下标位置开始查找字符串s出现的位置
size_t string::find(const char* s, size_t pos) const
{
	const char* ptr = strstr(_str + pos, s);
	if (ptr == nullptr)
	{
		return npos;
	}
	else {
		return ptr - _str;
	}
}
4.4删除字符的接口 
//从pos位置开始删除长度为len个字符
string& string::erase(size_t pos, size_t len)
{
	assert(pos < _size);
	if (len == npos || pos + len >= _size)
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else {
		strcpy(_str + pos, _str + pos + len);
		_size -= len;
	}
	return *this;
}

五、string类的迭代器

string::iterator string::begin()
{
	return _str;
}
string::iterator string::end()
{
	return _str+_size;
}
string::const_iterator string::begin() const
{
	return _str;
}
string::const_iterator string::end() const
{
	return _str+_size;
}

六、string类中[]成员重载 

//[]成员重载用于返回字符串中指定下标字符串的引用
char& string::operator[](size_t index)
{
	assert(index <= _size);
	return _str[index];
}
//const成员函数是供const对象调用的
const char& string::operator[](size_t index) const
{
	assert(index <= _size);
	return _str[index];
}

七 、string类中字符串比较运算符重载

bool string::operator<(const string& s)const
{
	int res = strcmp(_str, s._str);
	if (res < 0)
		return true;
	return false;
}

bool string::operator<=(const string& s)const
{
	return !(*this > s);
}
bool string::operator>(const string& s)const
{
	int res = strcmp(_str, s._str);
	if (res > 0)
		return true;
	return false;
}
bool string::operator>=(const string& s)const
{
	return !(*this < s);
}
bool string::operator==(const string& s)const
{
	int res = strcmp(_str, s._str);
	if (res == 0)
		return true;
	return false;
}
bool string::operator!=(const string& s)const
{
	return !(*this == s);
}

八 、string类中流插入和流提取运算符重载

ostream& operator<<(ostream& cout, const string& s)
	{
		for (auto ch : s)
		{
			cout << ch;
		}
		return cout;
	}
	istream& operator>>(istream& cin, string& s)
	{
		s.clear();
		char buff[128];
		char ch = cin.get(); 
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = cin.get();
		}
		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return cin;
	}

九、完整代码 

#include"string.h"
namespace bit {

	string::string(const char* str)
	{
		_size = strlen(str);
		_capacity = _size;
		_str = new char[_capacity + 1];
		strcpy(_str, str);
	}
	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)
	{
		string tmp(s._str);//构造
		swap(tmp);
	}
	string& string::operator=(string s)//传值调用拷贝构造
	{
		swap(s);
		return *this;
	}
	/*string::string(const string& s)
	{
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_capacity = s._capacity;
		_size = s._size;
	}
	string& string::operator=(const string& s)
	{

		if (this != &s)
		{
			char* tmp = new char[s._capacity + 1];
			strcpy(tmp, s._str);
			delete[] _str;
			_str = tmp;
			_capacity = s._capacity;
			_size = s._size;
		}
		return *this;
	}*/
	string::~string()
	{
		delete[] _str;
		_str = nullptr;
		_capacity = 0;
		_size = 0;
	}
	string::iterator string::begin()
	{
		return _str;
	}
	string::iterator string::end()
	{
		return _str + _size;
	}
	string::const_iterator string::begin() const
	{
		return _str;
	}
	string::const_iterator string::end() const
	{
		return _str + _size;
	}
	void string::push_back(char ch)
	{
		if (_size == _capacity)
		{
			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newCapacity);
		}
		_str[_size] = ch;
		_size++;
		_str[_size] = '\0';
	}
	void string::append(const char* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		strcpy(_str + _size, str);
		_size += len;
	}
	string& string::operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}
	string& string::operator+=(const char* str)
	{
		append(str);
		return *this;
	}
	void string::clear()
	{
		_size = 0;
		_str[0] = '\0';
	}
	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;
	}
	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 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 string::reserve(size_t newCapacity)
	{
		// 如果新容量大于旧容量，则开辟空间
		if (newCapacity > _capacity)
		{
			char* str = new char[newCapacity + 1];
			strcpy(str, _str);
			// 释放原来旧空间,然后使用新空间
			delete[] _str;
			_str = str;
			_capacity = newCapacity;
		}
	}
	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];
	}
	bool string::operator<(const string& s)const
	{
		int res = strcmp(_str, s._str);
		if (res < 0)
			return true;
		return false;
	}

	bool string::operator<=(const string& s)const
	{
		return !(*this > s);
	}
	bool string::operator>(const string& s)const
	{
		int res = strcmp(_str, s._str);
		if (res > 0)
			return true;
		return false;
	}
	bool string::operator>=(const string& s)const
	{
		return !(*this < s);
	}
	bool string::operator==(const string& s)const
	{
		int res = strcmp(_str, s._str);
		if (res == 0)
			return true;
		return false;
	}
	bool string::operator!=(const string& s)const
	{
		return !(*this == s);
	}
	ostream& string::operator<<(ostream& cout, const string& s)
	{
		for (auto ch : s)
		{
			cout << ch;
		}
		return cout;
	}
	istream& operator>>(istream& cin, string& s)
	{
		s.clear();
		char buff[128];
		char ch = cin.get();
		int i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[i] = '\0';
				s += buff;
				i = 0;
			}
			ch = cin.get();
		}
		if (i > 0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return cin;
	}
	size_t string::find(char c, size_t pos) const
	{
		for (size_t i = pos; i < _size; i++)
		{
			if (_str[i] == c)
			{
				return pos;
			}
		}
		return npos;
	}
	size_t string::find(const char* s, size_t pos) const
	{
		const char* ptr = strstr(_str + pos, s);
		if (ptr == nullptr)
		{
			return npos;
		}
		else {
			return ptr - _str;
		}
	}
	string& string::insert(size_t pos, char c)
	{
		assert(pos <= _size);
		if (_size == _capacity)
		{
			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
			reserve(newCapacity);
		}
		size_t end = _size + 1;
		while (end > pos)
		{
			_str[end] = _str[end - 1];
			--end;
		}
		_str[pos] = c;
		_size++;

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

}

 

坏..
关注
  • 11
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++中string的模拟实现
09-01
在 C++ 的标准库中，`std::string` 提供了 `push_back()` 成员函数来实现这个功能，但在我们的模拟实现中，我们需要自己创建这个功能： ```cpp void String::Push_Back(char c) { if (_sz == _capacity) { // 如果...
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
利用C++实现从std::string类型到bool型的转换
01-20
利用输入字符串流：std::istringstream 代码如下:bool b;std::string s = “true”;std::istringstream(s) >> std::boolalpha >>... 您可能感兴趣的文章:详解C++中String类模拟实现以及深拷贝浅拷贝自己模拟写C++中的St
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
C++ day3
2301_81402136的博客
06-17 277
【代码】C++ day3。
C的I/O操作
weidl001的博客
06-17 742
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
C语言 指定一个数字输出区间内的一个斐波那契数列
Random_N1的博客
06-20 346
/ 函数用于计算并打印从1到n的斐波那契数列a = b;b = next;int num;return 0;
STL中vector、list、map和set的主要区别
2402_84885073的博客
06-16 348
在C++的STL（Standard Template Library）中，是四种常用的容器，它们各自具有不同的特性和用途。
项目篇：加入Python程序之如何在Python中使用C++？
Francis的博客
06-19 284
项目篇：加速Python程序之如何在Python中使用C++？通常像一些耗时的操作，我们期望在C++中去实现，然后使用Python去调用对应的接口，或者因为底层库的原因，需要支持对外的Python API，那么我们通常需要支持在Python中访问C++，如何实现呢？方法比较多，本节以pybind11为例，引入一个完整的项目工程模版，如果你后续有这种需求，可以基于模版去修改。注：(懒人版)本节的所有...
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 剩余银饰的重量(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-17 171
K小姐从二手市场收集了 NNN 块银饰，每块银饰的重量都是正整数。这些银饰会被熔化用于打造新的饰品。每一回合，K小姐会选出三块最重的银饰一起熔掉。假设银饰的重量分别为 xxx、yyy 和 zzz，且 x≤y≤zx \\le y \\le zx≤y≤z。那么熔掉的可能结果如下： 1\. 如果 x\=y\=zx = y = zx\=y\=z，那么三块银饰都会被完全熔掉。 2\. 如果 x\=yx = yx\=y 且 y≠zy \\ne zy̸\=z，会剩余重量为 z−yz - yz−y 的银块无法被熔掉。
C++ 子集合枚举
06-17 248
给定一个正整数数组 nums[], 求所有可能的组合，使得组合中的元素和等于target, 例如: nums 为 {3, 4, 5}, target 为 9, 解为 {3, 3, 3}, {4, 5}
0621# C++八股 1.成员初始化列表的概念？以及为什么使用它会快一点？2.重写Override和重载Overload区别
qq_52784762的博客
06-21 683
成员初始化列表：用于在构造函数体执行之前初始化成员变量，提供更高效的初始化方式。直接初始化 vs. 赋值初始化：直接初始化避免了多余的默认构造和赋值操作，提高了性能。使用场景：特别适用于必须初始化的成员变量（如常量和引用），以及需要提高效率的情况。
C++通过VS2022使用Conan2.0安装fmt库实现控制台彩色打印
weixin_74027669的博客
06-17 435
C++通过VS2022使用Conan2.0安装fmt库
C语言之字符处理函数
最新发布
上善若泪
06-23 582
注意：本例程将字符串中大写字母转换为小写字母并输出，但并不改变原数组中的内容，只是在输出时将大写字母转换为小写字母，而本身是小写字母的字符或非字母字符，则返回原值。函数功能：检查字符c是否是除字母、数字、空格之外的可打印字符，也就是检查字符c是否是标点字符。函数功能：检查字符c 是否是ASCII码，所谓ASCII码是指0x00~0x7F之间的字符。函数功能：检查字符c是否是除了空格符外的可打印字符，其ASCII码在0x21-0x7e之间。返回值：当c为空格符或制表符时，返回1，否则返回0。
C语言 判断两个数中的较大者
Random_N1的博客
06-20 148
printf("输入两个整数: ");printf("较大的数是: %d\n", num1);} else {printf("较大的数是: %d\n", num2);return 0;
Ubuntu系统配置C/C++编译环境
m0_73500130的博客
06-21 930
在Ubuntu系统中安装和学习C语言非常的方便，与Windows复杂的环境配置不同，Ubuntu提供了多种C/C++开发工具，如GCC（GNU Compiler Collection）、GDB（GNU Debugger）和Valgrind等。这些工具不仅功能强大，而且大多数都是开源的.
算法设计与分析：动态规划法求扔鸡蛋问题 C++
aw2371的博客
06-21 1350
算法设计与分析：动态规划法求扔鸡蛋问题 三种方法：常规动态规划、动态规划加二分查找最优x、动态规划加逆向求解
C语言 | Leetcode C语言题解之第164题最大间距
m0_59237910的博客
06-18 329
C语言 | Leetcode C语言题解之第164题最大间距
pta 实验九 类库和标准库 C++
wuyufei_sun的博客
06-20 887
【代码】pta 实验九 类库和标准库 C++
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值