【C++】string类模拟实现：探索其内部机制

已于 2024-05-31 17:40:46 修改
阅读量1.9k 收藏 133
点赞数 159
分类专栏： C++从入门到进阶 文章标签： c++ iphone 开发语言 c语言
于 2024-05-16 22:30:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Renswc/article/details/138964854
版权

💞💞 前言

hello hello~ ，这里是大耳朵土土垚~💖💖 ，欢迎大家点赞🥳🥳关注💥💥收藏🌹🌹🌹
在这里插入图片描述

💥个人主页：大耳朵土土垚的博客
💥 所属专栏：C++入门至进阶
这里将会不定期更新有关C++的内容，希望大家多多点赞关注收藏💖💖

目录

1.string类基本框架

通过对string类的学习，我们知道string类的模拟实现最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数，以下是对模拟实现string类变量以及函数的封装：

为了防止与库里面string类名字重复，我们将自己模拟实现的string类放在tutu的命名空间中（名字可以自定义），这样使用时就不会冲突了；其次对于string类的模拟实现我们采用声明与定义分离，方便大家查看string类中包含哪些函数；如下是对string类的声明：

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;

namespace tutu	//命名空间，可自定义名字
{
	class string	//定义string类
	{
	public:

		//string();		//构造函数
		string(const char* str = "");
		string(const string& s);

		//赋值运算符重载
		string& operator=(const string& s);

		//析构函数
		~string();

		typedef char* iterator;	//定义迭代器
		typedef const char* const_iterator;//常量使用的迭代器

		iterator begin();	
		iterator end();

		const_iterator begin() const;
		const_iterator end() const;


		//获取字符串指针
		const char* c_str() const;	
		
		//获取string类的容量
		size_t size() const;
		size_t capacity()const;

		//[]重载
		char& operator[](size_t pos);	
		const char& operator[](size_t pos) const;	//常量版本

		//空间操作
		void reserve(size_t n);	//预留空间
		void resize(size_t n, char ch = '\0');//重设空间大小
		bool empty()const;//判断字符串是否为空
		void clear();//清空字符串



		//尾插操作
		void push_back(char ch);//尾插字符
		void append(const char* str);//插入字符串

		//+=重载
		string& operator+=(char ch);//尾插字符
		string& operator+=(const char* str);//尾插字符串

		//在pos位置插入
		void insert(size_t pos, char ch);
		void insert(size_t pos, const char* str);
		//删除pos位置的值
		void erase(size_t pos = 0, size_t len = npos);

		//查找字符/字符串
		size_t find(char ch, size_t pos = 0);
		size_t find(const char* str, size_t pos = 0);



		//交换
		void swap(string& s);

		//截取字符串
		string substr(size_t pos = 0, size_t len = npos);

		//运算符重载
		bool operator<(const string& s) const;
		bool operator>(const string& s) const;
		bool operator<=(const string& s) const;
		bool operator>=(const string& s) const;
		bool operator==(const string& s) const;
		bool operator!=(const string& s) const;
	private:
		// char _buff[16];
		char* _str = nullptr;

		size_t _size = 0;
		size_t _capacity = 0;

		const static size_t npos = -1;
	};
	
	//流插入提取重载
	istream& operator>> (istream& is, string& str);
	ostream& operator<< (ostream& os, const string& str);
}

2.string类模拟实现

因为定义和声明分离，所以我们对函数实现时，需要带作用限定符string：：表明是实现这个类中的函数

2.1构造函数实现

✨string(const char* str)

可以用字符串来构造string类：string s1("Hello World");

 string:: string(const char* str)
 {
     size_t len = strlen(str);	//计算字符串长度
     _str = new char[len + 1];	//开辟空间
     _size = _capacity = len;	//设置capacity和size值
     strcpy(_str, str);			//拷贝字符串
 }

这里注意开辟空间 _str = new char[len + 1];要+1，为了存放字符'\0';并且 strcpy(_str, str); 会将str中的'\0'拷贝给_str，所以不需要手动拷贝。此外注意缺省参数在声明写，定义就不需要写了。

✨ string(const string& s)

可以用另一个string对象来构造string对象：string s2(s1);

string::string(const string& s)
{
	_str = new char[s._capacity + 1];
	strcpy(_str, s._str);
	_size = s._size;
	_capacity = s._capacity;
}

2.2赋值运算符重载

✨ string& operator=(const string& s)

类似于赋值，可以将string对象赋值给另一个string对象 string s1 = s2;此外还可以string s1 = "Hello World;"利用隐式类型转换使用字符串赋值，实现代码如下：

string& string::operator=(const string& s)
{
	if (this != &s)
	{
		char* tmp = new char[s._capacity + 1];
		strcpy(tmp, s._str);
		delete[] _str;
		_str = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
	}

这里注意在赋值之前需要将string类的对象中之前存放的空间释放掉delete[] _str;

2.3析构函数

✨ ~string()

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

🥳🥳测试代码如下：

namespace tutu
{
	void Test1()
	{
		tutu::string s1 = "hello";
		tutu::string s2(s1);
		tutu::string s3 = s1;
	}
	
}

结果如下：
在这里插入图片描述

2.4迭代器

迭代器可以通过指针类比，它们可以指向容器中的某个元素，并且可以通过操作迭代器来访问和修改容器中的元素。在实现时先要对它进行定义：typedef char* iterator; //定义迭代器 typedef const char* const_iterator;//常量使用的迭代器，因为我们实现的是string类是字符串，所以将char*typedef,这些都放在声明中。

✨普通迭代器

string::iterator string::begin()
{
    return _str;	//返回字符串指针
}

string::iterator string::end()
{
    return _str + _size;	//返回字符串指向'\0'的指针，也就是最后一个元素的下一个
}

✨常量迭代器

string::const_iterator string::begin() const
{
    return _str;
}

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

2.5获取字符串指针

✨const char* c_str() const

//获取字符串指针
const char* string::c_str()const
{
    return _str;
}

2.6获取string类的容量

✨ size_t size() const

    size_t string::size()const
    {
        return _size;
    }

✨ size_t capacity()const

size_t string::capacity()const
    {
        return _capacity;
    }

2.7[]重载

✨ char& operator[](size_t pos)

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

✨ const char& operator[](size_t pos) const

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

2.8空间操作

✨ void reserve(size_t n)

void string::reserve(size_t n)
{
    //1.n <= capacity，不改变底层空间大小
    if (n <= _capacity)
    {
        //什么都不干
    }
    //2.n > capacity
    else
    {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        _capacity = n;
    }
   
}

为string类对象预留空间，这里要注意当n <= capacity时，不会进行缩小空间。

✨ void resize(size_t n, char ch = ‘\0’)

 void string::resize(size_t n, char ch)//?怎么将后面的都设置为ch,尾插
{
    //1.n <= capacity
    if (n <= _capacity)
    {
        if (n <= _size)
        {
            //什么都不干
        }
        else
        {
            for (int i = _size; i < n; i++)
            {
                _str[i] = ch;
            }
        }
    }
    //2.n > capacity
    else
    {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;
        for (int i = _size; i < n; i++)
        {
            _str[i] = ch;
        }
        _capacity = n;  //扩容了capacity要改变
    }
    _str[n] = '\0';
    _size = n;
}

这里注意当n<_size时，也就是字符串本身大小大于要设置的空间大小时，直接将n位置的字符设置为'\0'即可，不改变底层空间大小。

✨ bool empty()const

 bool string::empty()const
 {
     return _size == 0;
 }

判断字符串是否为空串

✨ void clear()

//清空字符串
  void string::clear()
  {
      //清除，底层空间不变
      _str[0] = '/0';
      _size = 0;
  }

这里清空字符串只是将它有效字符设为0，不改变底层空间大小

2.9尾插操作

✨void push_back(char ch)

 void string::push_back(char ch)
 {
     if (_size == _capacity)//判断是否需要扩容
     {
         size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity; 
         reserve(newcapacity);
         _capacity = newcapacity;
     }
     
     _str[_size] = ch;
     _str[_size+1] = '\0';
     _size++;
 }

✨void append(const char* str)

void string::append(const char* str)
{
    size_t len = strlen(str);
    reserve(_size + len);
    strcpy(_str + _size, str);
    _size += len;
}

因为reserve对于大于_size + len的空间不会缩小，所以我们直接使用reserve就行，不需要判断_capacity>_size+len的情况

✨+=重载

 string& string::operator+=(char ch)	//+=字符
 {
     push_back(ch);
     return *this;
 }

 string& string::operator+=(const char* str)	//+=字符串
 {
     append(str);
     return *this;
 }

+=重载和push_back、append实现原理一样我们只需要复用它们即可

🥳🥳测试代码如下：

using namespace tutu
{
void Test7()
{
	tutu::string s1("hello");
	//尾插字符
	s1.push_back('x');
	cout << s1.c_str() << endl;
	s1 += "world";
	cout << s1.c_str() << endl;

	//尾插字符串
	s1.append("tutu");
	cout << s1.c_str() << endl;
}
}

结果如下：
在这里插入图片描述

2.10在pos位置插入

✨void insert(size_t pos, char ch)

// 在pos位置上插入字符c/字符串str

void string::insert(size_t pos, char ch)
{
    assert(pos <= _size);
   
    if (_size == _capacity)
     {
        size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
        reserve(newcapacity);
     }
    size_t end = _size ;//'\0'也有
    while (end >= pos)  
    {
        _str[end+1] = _str[end];
        end--;
    }
    _size++;
    _str[pos] = ch; 
}

这里插入要挪动数据；注意while循环的判断条件end >= pos，又因为end和pos都是size_t无符号整型，所以当_size=0时，end无论怎么- - 都不会小于_size，也就是会陷入死循环

测试代码如下：

namespace tutu
{
	void Test2()
	{
		tutu::string s1 = "hello";
		s1.insert(0, 'x');
	}
}

结果如下：
在这里插入图片描述

程序出现异常

🥳🥳解决办法有两种

  • 将size_t类型强制转换为int类型
// 在pos位置上插入字符c/字符串str

void string::insert(size_t pos, char ch)
{
    assert(pos <= _size);
   
    if (_size == _capacity)
     {
        size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
        reserve(newcapacity);
     }
    //size_t end = _size ;//'\0'也有
    //while (end >= pos)   //出现异常
    //{
    //    _str[end+1] = _str[end];
    //    end--;
    //}
    int end = _size;//'\0'也有
    while (end >= (int)pos)   //防止越界
    {
        _str[end + 1] = _str[end];
        end--;
    }
    _size++;
    _str[pos] = ch; 
}
  • 将循环条件改成>

将end=_size+1,这样循环条件就可以是end >= pos

// 在pos位置上插入字符ch/字符串str

void string::insert(size_t pos, char ch)
{
    assert(pos <= _size);
   
    if (_size == _capacity)
     {
        size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
        reserve(newcapacity);
     }
    //size_t end = _size ;//'\0'也有
    //while (end >= pos)   //出现异常
    //{
    //    _str[end+1] = _str[end];
    //    end--;
    //}
    size_t end = _size+1;
    while (end > pos)   
    {
        _str[end] = _str[end-1];	//注意这里也要相应-1
        end--;
    }
    _size++;
    _str[pos] = ch; 
}

✨void insert(size_t pos, const char* str)

void string::insert(size_t pos, const char* str)
{
    int end = _size;//'\0'也有
    size_t len = strlen(str);
    reserve(_size + len);//扩容
    while (end >= (int)pos)	//这里使用强制类型转换
    {
        _str[end + len] = _str[end];
        end--;
    }
    mencpy(_str + pos, str, len);
    _size += len;
}

🥳🥳测试代码如下：

namespace tutu
{
	void Test3()
	{
		tutu::string s1 = "hello";
		s1.insert(0, 'x');
		s1.insert(3, "abc");
		cout << s1.c_str() << endl;
	}
}

结果如下：
在这里插入图片描述

2.11在pos位置删除

✨void erase(size_t pos = 0, size_t len = npos)

    // 删除pos位置上的元素

void string::erase(size_t pos, size_t len)
  {
      assert(pos < _size);
      if (len >= _size - pos) //如果一直删到尾，就直接将pos位置置为'\0'
      {
          _str[pos] = '\0';
          _size = pos;
      }
      else
      {
          strcpy(_str + pos, _str + pos + len);   //将后面的字符串拷贝到前面
          _size -= len;
      }
  }

🥳🥳测试代码如下：

using namespace tutu
{
void Test8()
{
	tutu::string s1("hello");
	//特定位置插入字符
	s1.insert(5, 'x');
	cout << s1.c_str() << endl;


	//删一个字符
	s1.erase(5, 1);
	cout << s1.c_str() << endl;

	//特定位置插入字符串
	s1.insert(5, "tutu");
	cout << s1.c_str() << endl;

	//删多个字符
	s1.erase(5, 4);
	cout << s1.c_str() << endl;
}
}

结果如下：
在这里插入图片描述

2.12查找字符/字符串

✨size_t find(char ch, size_t pos = 0)

 // 返回ch在string中第一次出现的位置

 size_t string::find(char ch, size_t pos)
 {
    
     for (size_t i = pos; i < _size; i++)
     {
         if (_str[i] == ch)
         {
             return i; //找到了返回下标
         }
     }
     return npos;  //没有找到返回npos
 }

✨size_t find(const char* str, size_t pos = 0)

 // 返回子串str在string中第一次出现的位置

 size_t string::find(const char* str, size_t pos)
 {
   
     char* tmp = strstr(_str + pos, str);
     if (tmp)    //1.如果找到了
     {
         return tmp - _str;
     }
     return npos;//2.没找到
 }

🥳🥳测试代码如下：

using namespace tutu
{
void Test6()
{
	tutu::string s1("hello world");
	cout << s1.find('o') << endl;
	cout << s1.find("wor") << endl;
}
}

结果如下：
在这里插入图片描述

2.13截取字符串

//截取字符串
string string::substr(size_t pos, size_t len)
{
    //如果len>_size-pos,就将pos位置后面全部拷贝
    if (len > _size - pos)
    {
        string sub(_str + pos);
        return sub;
    }
    else
    {
        string sub;
        sub.reserve(len);
        for (size_t i = 0; i < len; i++)
        {
            sub += _str[pos + i];
        }
        return sub;
    }
}

🥳🥳测试代码如下：

using namespace tutu
{
void Test4()
{
	tutu::string url("https://blog.csdn.net/Renswc?type=blog");
	size_t pos1 = url.find(':');
	tutu::string url1 = url.substr(0, pos1 - 0);
	cout << url1.c_str() << endl;
	
	size_t pos2 = url.find('/', pos1 + 3);
	tutu::string url2 = url.substr(pos1 + 3, pos2 - (pos1 + 3));
	cout << url2.c_str() << endl;
	
	tutu::string url3 = url.substr(pos2 + 1);
	cout << url3.c_str() << endl;
}
}

结果如下：
在这里插入图片描述

2.14交换函数

✨void swap(string& s)

 //交换
 void string::swap(string& s)
 {
     //使用标准库里面的交换函数
     std::swap(_str, s._str);
     std::swap(_size, s._size);
     std::swap(_capacity, s._capacity);
 }

2.15运算符重载

这里只要实现<和 == 或者<和 == 就可以代码复用到其他的运算符上，使用strcmp函数比较字符串

✨bool operator>(const string& s) const

bool string::operator>(const string& s)const
{
    return strcmp(_str, s._str) > 0;
}

✨bool operator==(const string& s) const

bool string::operator==(const string& s)const
{
    return *_str == *s._str;
}

✨bool operator<(const string& s) const

bool string::operator<(const string& s) const
{
    return !(*this >= s);
}

✨bool operator<=(const string& s) const

bool string::operator<=(const string& s)const
{
    return !(*this > s);
}

✨bool operator>=(const string& s) const

bool string::operator>=(const string& s)const
{
    return *this > s || *this == s;
}

✨bool operator!=(const string& s) const

bool string::operator!=(const string& s)const
{
    return !(*this == s);
}

2.16流插入提取

✨istream& operator>> (istream& is, string& str)

//流提取
istream& operator>> (istream& is, string& str)
{
    str.clear();
    char ch = is.get();
    while (ch != ' ' && ch != '\n')
    {
        str += ch;
        ch = is.get();
    }

    return is;
}

这里每次读取字符容量满了都要进行扩容非常消耗时间和空间，而且我们是两倍两倍的扩容，所以很可能会有很多剩余的空间无法使用，所以我们可以使用下面的方式来实现以节省空间：

//输入流重载

istream& operator>>(istream& in, string& s)
{
    s.clear();
    char ch;
    ch = in.get();
    char buff[128];//缓冲数组，最后一个存放'\0',所以最多读取127个
    size_t i = 0;
    while (ch != ' ' && ch != '\n')//遇到空格和换行停止读取
    {
        buff[i++] = ch;
        if (i == 127) //数组满了就将字符挪动到s中，然后再循环知道读完
        {
            buff[127] = '\0';
            s += buff;
            i = 0;
        }
        ch = in.get();
    }
    //如果没有读满数组，还有剩余字符
    if (i > 0)
    {
        buff[i] = '\0';
        s += buff;
    }
    return in;
}

输入流从屏幕上读取数据会覆盖原来的数据，所以我们使用clear先清理一下,然后创建一个数组来存放流读取到的字符，因为数组在函数调用完会自动释放不会占用过多的空间，一次性读取127个，读完就将它**+=到s中**，然后再从0开始读取，直到遇到空格或者换行，读取结束，如果此时数组里面还有字符就将它+=到s中

✨ostream& operator<< (ostream& os, const string& str)

//流插入
ostream& operator<< (ostream& os, const string& str)
{
    for (size_t i = 0; i < str.size(); i++)
    {
        os << str[i];
    }

    return os;
}

这里我们不需要将上述插入提取函数设置为友元，因为我们没有访问成员变量，访问的是公有的成员函数，也就不会存在越界访问

🥳🥳测试代码如下：

using namespace tutu
{
void Test5()
{
	tutu::string s1("hello world");
	cout << s1 << endl;
	
	cin >> s1;
	cout << s1 << endl;
}
}

结果如下：
在这里插入图片描述

这里看到遇到空格就没有继续读取了，只读了hello，后面的tutu没读

3.另一种写法

对于拷贝构造函数以及赋值运算符重载我们还可以实现一种现代写法

  • 拷贝构造
string::string(const string& s)
{
    /*_str = new char[s._capacity + 1];
    strcpy(_str, s._str);
    _size = s._size;
    _capacity = s._capacity;*/
    string tmp(s._str);
    swap(tmp);
}

让swap函数帮助我们实现拷贝构造，在函数调用完成会自动调用析构函数释放原来的空间

  • 赋值运算符重载
string& string::operator=(const string& s)
{
    if (this != &s) 
    {
        /*char* tmp = new char[s._capacity + 1];
        strcpy(tmp, s._str);
        delete[] _str;
        _str = tmp;
        _size = s._size;
        _capacity = s._capacity;*/
        string tmp(s._str);
        swap(tmp);
       
    }
    return *this;
}

此外对于赋值运算符重载还可以：

 string& string::operator=(string tmp)
 {
     swap(tmp);
     return *this;
 }

这里注意给的参数没有使用引用，直接就是对参数的临时拷贝，交换完就释放空间；所以如果要使用的话记得把声明也改一下

4.string类模拟实现完整代码

💫函数代码

#include"string.h"
namespace tutu
{
    
        string::string(const char* str)
        {
            size_t len = strlen(str);
            _str = new char[len + 1];
            _size = _capacity = len;
            strcpy(_str, str);
        }

        string::string(const string& s)
        {
            _str = new char[s._capacity + 1];
            strcpy(_str, s._str);
            _size = s._size;
            _capacity = s._capacity;
        }
        string& string::operator=(const string& s)
        {
            if (this != &s) 
            {
                char* tmp = new char[s._capacity + 1];
                strcpy(tmp, s._str);
                delete[] _str;
                _str = tmp;
                _size = s._size;
                _capacity = s._capacity;
               
            }
            return *this;
        }

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



       //

        // iterator

        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;
        }


        //获取字符串指针
        const char* string::c_str()const
        {
            return _str;
        }


     

      //  void string::swap(string& s)
      //  {
      //      string tmp(s);

      //  }

     

        /

        // access

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

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



        /

        // capacity

        size_t string::size()const
        {
            return _size;
        }

        size_t string::capacity()const
        {
            return _capacity;
        }

       

        void string::reserve(size_t n)
        {
            //1.n <= capacity，不改变底层空间大小
            if (n <= _capacity)
            {
                //什么都不干
            }
            //2.n > capacity
            else
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }

        }


        void string::resize(size_t n, char ch)//?怎么将后面的都设置为ch,尾插
        {
            //1.n <= capacity
            if (n <= _capacity)
            {
                if (n <= _size)
                {
                    //什么都不干
                }
                else
                {
                    for (int i = _size; i < n; i++)
                    {
                        _str[i] = ch;
                    }
                }
            }
            //2.n > capacity
            else
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                for (int i = _size; i < n; i++)
                {
                    _str[i] = ch;
                }
                _capacity = n;  //扩容了capacity要改变
            }
            _str[n] = '\0';
            _size = n;
        }

        
        //判断字符串是否为空串
        bool string::empty()const
        {
            return _size == 0;
        }


        //清空字符串
          void string::clear()
          {
              //清除，底层空间不变
              _size = 0;
              _str[0] = '/0';

          }


            /

       // modify

       void string::push_back(char ch)
       {
           if (_size == _capacity)//判断是否需要扩容
           {
               size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity; 
               reserve(newcapacity);
               _capacity = newcapacity;
           }
           
           _str[_size] = ch;
           _str[_size+1] = '\0';
           _size++;
       }

       string& string::operator+=(char ch)
       {
           push_back(ch);
           return *this;
       }

       void string::append(const char* str)
       {
           size_t len = strlen(str);
           reserve(_size + len);
           strcpy(_str + _size, str);
           _size += len;
       }

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


      



        // 在pos位置上插入字符ch / 字符串str

        void string::insert(size_t pos, char ch)
        {
            assert(pos <= _size);
           
            if (_size == _capacity)
             {
                size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
                reserve(newcapacity);
             }
            //size_t end = _size ;//'\0'也有
            //while (end >= pos)   //出现异常
            //{
            //    _str[end+1] = _str[end];
            //    end--;
            //}
            size_t end = _size+1;//'\0'也有
            while (end > pos)   
            {
                _str[end] = _str[end-1];
                end--;
            }
            _size++;
            _str[pos] = ch; 
        }

        void string::insert(size_t pos, const char* str)
        {
            int end = _size;
            size_t len = strlen(str);
            reserve(_size + len);//扩容
            while (end >= (int)pos)
            {
                _str[end + len] = _str[end];
                end--;
            }
            memcpy(_str + pos, str, len);
            _size += len;
        }



        // 删除pos位置上的元素

      void string::erase(size_t pos, size_t len)
        {
            assert(pos < _size);
            if (len >= _size - pos) //如果一直删到尾，就直接将pos位置置为'\0'
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else
            {
                strcpy(_str + pos, _str + pos + len);   //将后面的字符串拷贝到前面
                _size -= len;
            }
        }

      // 返回ch在string中第一次出现的位置

      size_t string::find(char ch, size_t pos)
      {
         
          for (size_t i = pos; i < _size; i++)
          {
              if (_str[i] == ch)
              {
                  return i; //找到了返回下标
              }
          }
          return npos;  //没有找到返回npos
      }

      // 返回子串str在string中第一次出现的位置

      size_t string::find(const char* str, size_t pos)
      {
        
          char* tmp = strstr(_str + pos, str);
          if (tmp)    //1.如果找到了
          {
              return tmp -_str;
          }
          return npos;//2.没找到
      }



      //截取字符串
      string string::substr(size_t pos, size_t len)
      {
          //如果len>_size-pos,就将pos位置后面全部拷贝
          if (len > _size - pos)
          {
              string sub(_str + pos);
              return sub;
          }
          else
          {
              string sub;
              sub.reserve(len);
              for (size_t i = 0; i < len; i++)
              {
                  sub += _str[pos + i];
              }
              return sub;
          }
      }


      //交换
      void string::swap(string& s)
      {
          //使用标准库里面的交换函数
          std::swap(_str, s._str);
          std::swap(_size, s._size);
          std::swap(_capacity, s._capacity);
      }
   
    
      /

      //relational operators



      bool string::operator>(const string& s)const
      {
          return strcmp(_str, s._str) > 0;
      }


      bool string::operator==(const string& s)const
      {
          return *_str == *s._str;
      }

      bool string::operator>=(const string& s)const
      {
          return *this > s || *this == s;
      }

      bool string::operator<(const string& s) const
      {
          return !(*this >= s);

      }

      bool string::operator<=(const string& s)const
      {
          return !(*this > s);
      }

      bool string::operator!=(const string& s)const
      {
          return !(*this == s);
      }

      流提取
      //istream& operator>> (istream& is, string& str)
      //{
      //    str.clear();
      //    char ch = is.get();
      //    while (ch != ' ' && ch != '\n')
      //    {
      //        str += ch;
      //        ch = is.get();
      //    }

      //    return is;
      //}

      //输入流重载

      istream& operator>>(istream& in, string& s)
      {
          s.clear();
          char ch;
          ch = in.get();
          char buff[128];//缓冲数组
          size_t i = 0;
          while (ch != ' ' && ch != '\n')//遇到空格和换行停止读取
          {
              buff[i++] = ch;
              if (i == 127) //数组满了就将字符挪动到s中，然后再循环知道读完
              {
                  buff[127] = '\0';
                  s += buff;
                  i = 0;
              }
              ch = in.get();
          }
          //如果没有读满数组，还有剩余字符
          if (i > 0)
          {
              buff[i] = '\0';
              s += buff;
          }
          return in;
      }
      //输出流重载
      ostream& operator<< (ostream& os, const string& str)
      {
          for (size_t i = 0; i < str.size(); i++)
          {
              os << str[i];
          }

          return os;
      }
 }

💫测试代码

namespace tutu
{
	void Test1()
	{
		tutu::string s1 = "hello";
		tutu::string s2(s1);
		tutu::string s3 = s1;
	}
	void Test3()
	{
		tutu::string s1 = "hello";
		s1.insert(0, 'x');
		s1.insert(3, "abc");
		cout << s1.c_str() << endl;

	}
	

	void Test4()
	{
		tutu::string url("https://blog.csdn.net/Renswc?type=blog");
		size_t pos1 = url.find(':');
		tutu::string url1 = url.substr(0, pos1 - 0);
		cout << url1.c_str() << endl;
		
		size_t pos2 = url.find('/', pos1 + 3);
		tutu::string url2 = url.substr(pos1 + 3, pos2 - (pos1 + 3));
		cout << url2.c_str() << endl;
		
		tutu::string url3 = url.substr(pos2 + 1);
		cout << url3.c_str() << endl;
	}
	void Test5()
	{
		tutu::string s1("hello world");
		cout << s1 << endl;
		
		cin >> s1;
		cout << s1 << endl;
	}
	void Test6()
	{
		tutu::string s1("hello world");
		cout << s1.find('o') << endl;
		cout << s1.find("wor") << endl;
	}

	void Test7()
	{
		tutu::string s1("hello");
		//尾插字符
		s1.push_back('x');
		cout << s1.c_str() << endl;
		s1 += "world";
		cout << s1.c_str() << endl;

		//尾插字符串
		s1.append("tutu");
		cout << s1.c_str() << endl;

		
	}
	void Test8()
	{
		tutu::string s1("hello");
		//特定位置插入字符
		s1.insert(5, 'x');
		cout << s1.c_str() << endl;


		//删一个字符
		s1.erase(5, 1);
		cout << s1.c_str() << endl;

		//特定位置插入字符串
		s1.insert(5, "tutu");
		cout << s1.c_str() << endl;

		//删多个字符
		s1.erase(5, 4);
		cout << s1.c_str() << endl;


	}
}
int main()
{
	tutu::Test8();
	return 0;
}

5.结语

以上就是自主实现string类的所有内容啦~ 完结撒花 ~🥳🎉🎉

大耳朵土土垚
关注
  • 159
    点赞
  • 踩
  • 133
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 129
    评论
专栏目录
【C++ 项目设计】通过C++ 实现Qt的信号槽机制
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-12 142
Qt的信号槽机制以其强大的解耦合和灵活性而闻名。通过在STL中实现这一机制，我们可以为不使用Qt框架的项目提供相同级别的解耦合和灵活性。这种解耦合使得代码的各个部分可以独立变化和扩展，而不会对其他部分产生影响，从而提高了整个项目的可维护性和可扩展性。
【C++杂货铺】探索vector的底层实现
春人.的博客
08-26 5366
本篇文章介绍了vector的使用，以及底层实现。
从string类的实现看C++类的四大函数(面试常见)
09-02
C++类一般包括构造函数、拷贝构造函数、析构函数和赋值函数四大函数，非常常见，本文给大家介绍从string类的实现看C++类的四大函数，一起看看吧
【C++初阶：STL —— string】string类 | 浅拷贝和深拷贝(传统写法和现代写法) | string类的模拟实现
wh128341的博客
03-29 2383
到这里我们就要学会能自己能看文档了，因为就这个 string 类来说就有一百多个接口函数，那肯定记不住呀，我们平时用的大概就二十个，一般我们都是学习它比较常用的，其它的大概熟悉它们有哪些功能，真要用到时再去查文档。可以看到其实 string 就是一个管理字符数组的顺序表，因为字符数组的使用广泛，C++ 就专门给了一个 string 类，由于编码原因，它写的是一个模板。针对 string，一般情况它有三个成员 —— char* _str、size_t _size、size_t _capacity，我们在下面模
【C++进阶】深入STL之string：模拟实现走进C++字符串的世界
EterNity_TiMe_的计算机学习之路
06-02 1731
在C++中，string是一个极其重要且常用的类，它为我们提供了丰富的字符串操作功能。然而，了解其背后的实现原理，不仅可以帮助我们更好地使用它，还能让我们对C++的内存管理、模板编程等有更深入的理解。本文将带你走进C++字符串的世界，通过模拟实现一个简单的string类，来探索其内部机制
【C++多线程 同步机制】：探索 从互斥锁到C++20 同步机制的进化与应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-10 1253
早期的多线程编程主要依赖于互斥锁（Mutex）和条件变量（Condition Variables）来实现线程间的同步。这种方式虽然有效，但也存在一定的局限性。比如，互斥锁在处理复杂的同步需求时可能会导致死锁。
【C++ 泛型编程 入门篇】C++模板类精讲：探索通用编程的魅力与实战应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-10 1412
C++模板是一种泛型编程技术，它使得程序员能够为一个类或函数定义通用的框架。通过这种方式，程序员可以编写一个适用于不同数据类型的算法，而无需针对每一种数据类型编写单独的版本。这使得代码更加简洁，易于维护，提高了程序的可重用性。
c++异步：asio的scheduler实现！
C语言与CPP编程的博客
08-19 1674
导语|前面的篇章《C++异步：libunifex的scheduler实现》中其实也提到过，libunifex的scheduler实现离实用级其实还有一些差距。对比asio相关的实现，处理细节和完备度上都有较大落差，基于总览篇提到的整体实践思路，我们将更多使用asio的scheduler来作为execution的底层调度器。所以从本篇开始，我们将详细介绍asio相关的实现，本篇主要介绍asio传...
【C++】STL——vector 深度剖析 及 模拟实现
m0_70980326的博客
04-21 922
深度剖析vector的底层结构及其模拟实现、详解vector的深拷贝问题、迭代器失效问题等。
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中String类模拟实现以及深拷贝浅拷贝
08-28
主要介绍了详解C++中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的模拟实现
09-01
主要为大家详细介绍了C++中string的模拟实现，感兴趣的小伙伴们可以参考一下
探索C++核心：类和继承的力量 《C++沉思录》第二部分解读
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-02 365
在C++中，类（Class）是构建程序的基石。类不仅仅是一种将数据和行为封装在一起的技术，它更是一种对现实世界抽象的表达。通过类，程序员能够创建出模拟现实世界对象的数据结构，使得代码更加直观和容易管理。
C++访问越界
m0_73537205的博客
06-02 664
常见场景 访问数组元素越界 vector容器访问等 vector<int>;vec<2>； 字符串访问越界string str;str[2]; array数组访问越界 字符串处理，没有添加’\0’字符，导致访问字符串的时候越界了； 使用类型强转，让一个大类型（派生类）的指针指向一块小内存（基类对象）了，然后指针解引用，访问的内存就越界了! 总之本质就是访问超过了系统分配的内存！
c++ - 模板(二)
最新发布
2302_79539362的博客
06-05 896
TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用。在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的。
CF Round 368 (Div. 2) C. Pythagorean Triples【数学 构造】
2301_80089588的博客
05-30 449
数学 构造
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
weixin_73886306的博客
05-30 475
无向图中两点(x1,y1)(x2,y2)是否连通(bfs&并查集)两种方法解决(c++)
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您需要创建一个动态数组来存储字符串，同时实现一些方法来操作它。比如说，您可以创建一个构造函数来初始化字符串，实现一个拼接方法来将两个字符串合并，还可以实现一个查找方法来搜索字符串中的特定字符或子串。这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大耳朵土土垚

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值