(C++ STL)string类的简单模拟实现与源码展示

于 2024-08-29 23:01:32 发布
阅读量868 收藏 24
点赞数 26
分类专栏： C++ STL 文章标签： c++ 算法 c++STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq3304968099/article/details/141607624
版权

string类的简单模拟实现

一、前言

C++ 为了更安全、简单的使用字符串，对 C语言 中的字符串和相关函数进行封装，实现了 string 类。接下来将会实现 string 与一部分常用的函数。

参考：legacy.cplusplus.com网站的 string

具体实现：

  1. string部分构造函数、析构函数、赋值运算符重载。
  2. Iterator 中的 begin、end。
  3. Capacity 中的 size、resize、capacity、reserve、clear、empty。
  4. Element access 中的 operator[]。
  5. Modifiers 中的 operator+=、append、push_back、insert、erase、swap、pop_back 。
  6. String operations 中的 c_str、find。
  7. Non-member function overload 中的 relational operators、operator>>、operator<<。

二、string 的成员变量

在 string.h 中：

namespace my
{
	class string
	{
	public:

		static const size_t npos = -1;

	private:

		char* _str;
		size_t _capacity;
		size_t _size;

	};
}
  1. npos 表示的是 string 的结束位子，详细可参考：C++中string::npos的一些用法总结
  2. _str 字符指针用来存储 在堆上开辟的 字符串数据的 地址。
  3. _capacity 表示容器空间大小，因为 C语言 字符串末尾隐藏了一个 ’ \0 '，则真实存储字符的容量为 _capacity - 1。
  4. _size 表示当前字符串大小(不含 ’ \0 ')。

三、string 的主要部分实现

考虑到代码复用，实现并不按照上述排列顺序，且只列举一部分重要的功能。

reserve

参考：std::string::reserve

C++ 对 string reserve函数规定：

  1. 当 原空间大小 小于 需求大小 时， 对原空间扩容到需求大小或其以上。
  2. 当 原空间 大于或等于 需求 时，非必要的缩减空间调整。

这里实现的空间增长为严格的 2 倍扩容，对于 序号 2 的情况采取直接忽视。

在 string.cpp 中：

void my::string::reserve(size_t n)
{
	if (n + 1 <= _capacity)			// 考虑末尾 '\0'
	{
		return;
	}

	size_t newCapacity = _capacity == 0 ? MY_STRING_INIT_CAPACITY : _capacity * 2;

	// n 仍然大于newCapacity时继续扩容
	// newCapacity <= n 等价 newCapacity < n + 1
	while (newCapacity <= n)	
	{
		newCapacity <<= 1;
	}

	char* str1 = nullptr;			// str1存储原空间地址	
	std::swap(str1, _str);	
	_str = new char[newCapacity];	// _str 新开空间后拷贝

	// _size >= _capacity 只出现在初始化时(这时 _size == _capacity == 0)
	// 以防止超出 _capacity 的非法内存访问
	memcpy(_str, str1, sizeof(char) * (_size >= _capacity ? _capacity : _size + 1));

	_capacity = newCapacity;
	delete[] str1;
}

Iterator

这里迭代器只对原生 char* 进行封装。

参考：std::string::begin
参考：std::string::end

这里只实现部分。

在 my::string 中：

        typedef char* iterator;

		iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }

operator[]

参考：std::string::operator[]

在 my::string 类中

        char& operator[](size_t index)
        {
            return *(_str + index);
        }

        const char& operator[](size_t index) const
        {
            return *(_str + index);
        }

insert

这里只实现两个。

参考：std::string::insert

在 string.cpp 中：

// 在 pos 位置上插入 字符ch / 字符串str，并返回该string
my::string& my::string::insert(size_t pos, char ch)
{
	assert(pos <= _size);

	reserve(++_size);

	// 将 pos 原位置与之后字符向后移动一步，再用 ch 覆盖 pos 当前原字符
	for (size_t end = _size; end >= pos + 1; --end)
	{
		_str[end] = _str[end - 1];
	}
	_str[pos] = ch;

	return *this;
}

my::string& my::string::insert(size_t pos, const char* str)
{
	assert(pos <= _size);

	size_t len = strlen(str);
	if (len != 0)
	{
		reserve(_size += len);

	// 将 pos 原位置与之后字符向后移动len步，再用 str 覆盖 pos 和之后原字符串
		for (size_t end = _size; end >= pos + len; --end)
		{
			_str[end] = _str[end - len];
		}
		strncpy(_str + pos, str, len);
	}

	return *this;
}

erase

这里只实现一个。

参考：std::string::erase

在 string.cpp 中：

// 删除 pos ~ pos + len 位置上的元素，并返回该 string
my::string& my::string::erase(size_t pos, size_t len)
{
	assert(pos < _size);

	if (len > _size)		// len 默认值为 npos, 此时不能加，会溢出
	{
		len = _size;
	}
							// 若后面还有数据需移动
	for (size_t end = pos; end < _size - len; ++end)
	{
		_str[end] = _str[end + len];
	}
	_size = (_size - pos <= len ? pos : _size - len);
	_str[_size] = '\0';		// '\0' 需单独处理

	return *this;
}

find

这里只实现两个。

参考：std::string::find

在 string.cpp 中：

// 返回 ch 在 string 中第一次出现的位置
size_t my::string::find(char ch, size_t pos) const
{
	assert(pos <= _size);

	size_t index = pos;
	while (index < _size)
	{
		if (_str[index] == ch)
		{
			break;
		}

		++index;
	}

	return index == _size ? npos : index;
}

// 返回子串 str1 在 string 中第一次出现的位置
size_t  my::string::find(const char* str1, size_t pos) const
{
	size_t len1 = strlen(str1);

	assert(pos + len1 <= _size);

	size_t index = pos;
	while (index + len1 <= _size)
	{
		if (strncmp(_str + index, str1, len1) == 0)
		{
			break;
		}

		++index;
	}

	return index + len1 <= _size ? index : npos;
}

resize

参考：std::string::resize

在 my::string 中：

        void resize(size_t n, char ch = '\0')
        {
            if (n > _size)
            {
                reserve(n);

                for (int i = _size + 1; i < n; ++i)
                {
                    _str[i] = ch;
                }
            }

            _str[_size = n] = '\0';
        }

构造、析构、赋值重载

参考：std::string::string
参考：std::string::~string
参考：std::string::operator=

在 my::string 中：

        string(const char* str1 = "")
            :_str(nullptr)
            ,_size(0)
            ,_capacity(0)
        {
            size_t len1 = strlen(str1);
            reserve(len1);
            memcpy(_str, str1, sizeof(char) * (len1 + 1));
            _size = len1;
        }

        string(const string& str1)
            :_str(nullptr)
            ,_size(0)
            ,_capacity(0)
        {
            reserve(str1.capacity());
            memcpy(_str, str1._str, sizeof(char) * (str1._size + 1));
            _size = str1._size;
        }

        ~string()
        {
            if (_str != nullptr)
            {
                delete[] _str;
                _str = nullptr;
            }

            _size = _capacity = 0;
        }

        void swap(string& str1)
        {
            std::swap(_str, str1._str);
            std::swap(_size, str1._size);
            std::swap(_capacity, str1._capacity);
        }

        string& operator=(string str1)
        {
            swap(str1);

            return *this;
        }

四、string 源代码

在 string.h 中：

#pragma once

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <cassert>

#define MY_STRING_INIT_CAPACITY 4

namespace my
{
    class string
    {
        friend std::ostream& operator<<(std::ostream& cout, const my::string& str1);

        friend std::istream& operator>>(std::istream& cin, my::string& str1);

    public:

        typedef char* iterator;

    public:

        string(const char* str1 = "")
            :_str(nullptr)
            ,_size(0)
            ,_capacity(0)
        {
            size_t len1 = strlen(str1);
            reserve(len1);
            memcpy(_str, str1, sizeof(char) * (len1 + 1));
            _size = len1;
        }

        string(const string& str1)
            :_str(nullptr)
            ,_size(0)
            ,_capacity(0)
        {
            reserve(str1.capacity());
            memcpy(_str, str1._str, sizeof(char) * (str1._size + 1));
            _size = str1._size;
        }

        ~string()
        {
            if (_str != nullptr)
            {
                delete[] _str;
                _str = nullptr;
            }

            _size = _capacity = 0;
        }

        void swap(string& str1)
        {
            std::swap(_str, str1._str);
            std::swap(_size, str1._size);
            std::swap(_capacity, str1._capacity);
        }

        string& operator=(string str1)
        {
            swap(str1);

            return *this;
        }

        //-----------------------------------------------------------

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }

        //-----------------------------------------------------------

        void push_back(char ch)
        {
            insert(_size, ch);
        }

        void pop_back()
        {
            erase(_size - 1, 1);
        }

        string& operator+=(char ch)
        {
            return insert(_size, ch);
        }

        void append(const char* str1)
        {
            insert(_size, str1);
        }

        string& operator+=(const char* str1)
        {
            return insert(_size, str1);
        }

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

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

        //-----------------------------------------------------------

        size_t size() const
        {
            return _size;
        }

        size_t capacity() const
        {
            return _capacity - 1;
        }

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

        void resize(size_t n, char ch = '\0')
        {
            if (n > _size)
            {
                reserve(n);

                for (int i = _size + 1; i < n; ++i)
                {
                    _str[i] = ch;
                }
            }

            _str[_size = n] = '\0';
        }

        void reserve(size_t n);

        //-----------------------------------------------------------

        char& operator[](size_t index)
        {
            return *(_str + index);
        }

        const char& operator[](size_t index) const
        {
            return *(_str + index);
        }

        //-----------------------------------------------------------

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

        bool operator>(const string& str1)
        {
            return strcmp(c_str(), str1.c_str()) > 0;
        }

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

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

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

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

        //-----------------------------------------------------------

        size_t find(char ch, size_t pos = 0) const;

        size_t find(const char* str1, size_t pos = 0) const;

        string& insert(size_t pos, char ch);

        string& insert(size_t pos, const char* str);

        string& erase(size_t pos = 0, size_t len = npos);

        static const size_t npos = -1;

    private:

        char* _str;
        size_t _capacity;
        size_t _size;

    };
}

在 string.cpp 中：

#include "string.h"

void my::string::reserve(size_t n)
{
	if (n + 1 <= _capacity)			// 考虑末尾 '\0'
	{
		return;
	}

	size_t newCapacity = _capacity == 0 ? MY_STRING_INIT_CAPACITY : _capacity * 2;

	// n 仍然大于newCapacity时继续扩容
	// newCapacity <= n 等价 newCapacity < n + 1
	while (newCapacity <= n)	
	{
		newCapacity <<= 1;
	}

	char* str1 = nullptr;			// str1存储原空间地址	
	std::swap(str1, _str);	
	_str = new char[newCapacity];	// _str 新开空间后拷贝

	// _size >= _capacity 只出现在初始化时(这时 _size == _capacity == 0)
	// 以防止超出 _capacity 的非法内存访问
	memcpy(_str, str1, sizeof(char) * (_size >= _capacity ? _capacity : _size + 1));

	_capacity = newCapacity;
	delete[] str1;
}

// 返回c在string中第一次出现的位置
size_t my::string::find(char ch, size_t pos) const
{
	assert(pos <= _size);

	size_t index = pos;
	while (index < _size)
	{
		if (_str[index] == ch)
		{
			break;
		}

		++index;
	}

	return index == _size ? npos : index;
}

// 返回子串str1在string中第一次出现的位置
size_t  my::string::find(const char* str1, size_t pos) const
{
	size_t len1 = strlen(str1);

	assert(pos + len1 <= _size);

	size_t index = pos;
	while (index + len1 <= _size)
	{
		if (strncmp(_str + index, str1, len1) == 0)
		{
			break;
		}

		++index;
	}

	return index + len1 <= _size ? index : npos;
}

// 在 pos 位置上插入 字符ch / 字符串str，并返回该string
my::string& my::string::insert(size_t pos, char ch)
{
	assert(pos <= _size);

	reserve(++_size);

	// 将 pos 原位置与之后字符向后移动一步，再用 ch 覆盖 pos 当前原字符
	for (size_t end = _size; end >= pos + 1; --end)
	{
		_str[end] = _str[end - 1];
	}
	_str[pos] = ch;

	return *this;
}

my::string& my::string::insert(size_t pos, const char* str)
{
	assert(pos <= _size);

	size_t len = strlen(str);
	if (len != 0)
	{
		reserve(_size += len);

	// 将 pos 原位置与之后字符向后移动len步，再用 str 覆盖 pos 和之后原字符串
		for (size_t end = _size; end >= pos + len; --end)
		{
			_str[end] = _str[end - len];
		}
		strncpy(_str + pos, str, len);
	}

	return *this;
}

// 删除 pos ~ pos + len 位置上的元素，并返回该 string
my::string& my::string::erase(size_t pos, size_t len)
{
	assert(pos < _size);

	if (len > _size)		// len 默认值为 npos, 此时不能加，会溢出
	{
		len = _size;
	}
							// 若后面还有数据需移动
	for (size_t end = pos; end < _size - len; ++end)
	{
		_str[end] = _str[end + len];
	}
	_size = (_size - pos <= len ? pos : _size - len);
	_str[_size] = '\0';		// '\0' 需单独处理

	return *this;
}

std::ostream& my::operator<<(std::ostream& out, const my::string& str1)
{
	out << str1.c_str();
	return out;
}

std::istream& my::operator>>(std::istream& in, my::string& str1)
{
	str1.clear();

	// 缓冲
	char buf[100] = { 0 };
	char ch = in.get();
	int i = 0;

	while (ch != ' ' && ch != '\n')
	{
		buf[i++] = ch;

		if (i >= 99)
		{
			str1 += buf;
			i = 0;
		}

		ch = in.get();
	}
	if (i > 0)
	{
		buf[i] = '\0';
		str1 += buf;
	}

	return in;
}
瞌睡不来
关注
  • 26
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ string源码
bcbobo21cn的专栏
06-03 3494
c和c++的string源代码 //String类源代码 //一.C字符串 //1. strlen(),计算字符串长度 int strlen(const char string) { int i=0; while(string[i]) i++; return i; } //2. strcpy(), 字符串拷贝. char *strcpy(char *destination, co
C++ STL 标准模板库介绍与入门
热门推荐
dvlinker的技术专栏
05-14 2万+
C++ STL 标准模板库概述与入门
C++_string简单源码剖析：string模拟实现
最新发布
Lvision2的博客
05-21 1094
接下来在另一个.cpp后缀的文件中一步一步的剖析实现。
c++ string 释放_源码分析C++的string实现
weixin_39906906的博客
11-26 801
我们平时使用C++开发过程中或多或少都会使用std::string，但您了解string具体是如何实现的吗，这里程序喵给大家从源码角度分析一下。读完本文相信您可以回答以下问题：string的常见的实现方式有几种？string类的内部结构是什么样子？string内部使用的内存是如何分配管理的？string是如何拷贝构造，如何析构的，有引用计数的概念吗？string的data()和c_str()函数有...
c++string类源码
04-01
c++string类源码 包括拷贝构造函数，生拷贝浅拷贝，追加函数，赋值函数，字符串比较函数，重载运算符等等
STL中string类模拟实现源码
08-06
内容简介，涵盖内容广泛。源码实现参照STL源码。
【STL源代码】C++标准库STL源代码下载
09-05
阅读STL源代码可以帮助我们理解C++容器和算法的底层实现，从而优化自己的代码，提高程序性能。同时，也能让我们更好地掌握C++模板机制，以及如何利用泛型编程来编写高效且可复用的代码。通过分析源码，我们可以学习...
【C++ STL】string 容器（介绍、使用、深浅拷贝、模拟实现、写时拷贝）
codewinter的博客
05-22 1537
文章目录前言一、STL - string 的介绍二、string 的使用（常用接口介绍）2.1 常见构造2.2 容量操作2.3 访问操作2.4 迭代器及遍历操作2.5 修改操作2.6 string 类的非成员函数重载2.7 补充一些接口三、string 类的模拟实现3.1 深浅拷贝（⭐重要）① 浅拷贝 & 深拷贝② 拷贝构造 & 赋值运算符重载（传统写法）③ 拷贝构造 & 赋值运算符重载（现代写法）3.2 string 类的结构3.3 string 类的迭代器3.4 一些成员函数的实
C++ STL源码
08-07
The STL was developed on SGI MIPSproTM C++ 7.0, 7.1, 7.2, and 7.2.1. If you are using the 7.0 compiler, you must compile using either the -n32 or the -64 flag; if you are using 7.1 or later, you may ...
c++string函数源码
07-20
c++string函数源码 无修改
c++中string类的源代码
12-27
关于string类的自定义，如果你对string不了解，可帮助你理解其功能有助于c++的学习
功能强大的String类源码(C++)
06-09
用C++语言实现的一个功能强大的String类，该类包含对字符串的各种灵活操作，40多个强大的API(CharAt,Length,IndexOf,Replace,Add,Insert,Remove.....), 为学习数据结构的朋友提供了很好的帮助。
C++语言string类的实现 完整源代码 pdf
11-14
C++语言string类的实现 完整源代码 pdf
C++中String类的实现
12-22
String是C++中的重要类型，程序员在C++面试中经常会遇到关于String的细节问题，甚至要求当场实现这个类。只是由于时间关系，可能只要求实现构造函数、析构函数、拷贝构造函数等关键部分。 　　String的实现涉及很多C++的基础知识、内存控制及异常处理等问题，仔细研究起来非常复杂，本文主要做一个简单的总结和归纳。 　　一 整体框架 　　面试时由于时间关系，面试官一般不会要求很详尽的String的功能，一般是要求实现构造函数、拷贝构造函数、赋值函数、析构函数这几个非常重要的部分。因为String里涉及动态内存的管理，默认的拷贝构造函数在运行时只会进行浅复制，即只复制内存区域的指针，
C++之string源代码详解
m0_57330725的博客
03-19 3667
stiring 相比于c的char 要方便多了，string里有很多的库函数，现在我们来把库函数的实现讲解下 #include<iostream> #include<string.h> #include<assert.h> using namespace std; namespace WGX//建一个空间域 { class string { public: typedef char* iterator;//迭代器 typedef const cha
C++String 类完整源代码
07-08 2644
MyString 类完整源代码   MyString.h文件 /*********************************************************** //Copyright (c) 2013 道合|SameIdeal.com  All rights reserved. ***********************************************
C++实现string （附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-25 271
C++实现string （附完整源码）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值