string模拟实现

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量66 收藏 1
点赞数
分类专栏： C++初阶 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80190376/article/details/134489580
版权

文章目录

流插入，流提取

friend ostream& operator<<(ostream& _cout, const zx::string& s)
        {
            for (size_t i = 0; i < s._size; i++)
            {
                _cout << s._str[i];
            }
            return _cout;
        }
        friend istream& operator>>(istream& _cin, zx::string& s)
        {
            s.clear();
            char Buff[129];
            size_t i = 0;
            char ch;
            ch = _cin.get();
            while (ch != ' ' && ch != '\n')
            {
                Buff[i++] = ch;
                if (i == 128)
                {
                    Buff[i] = '\0';
                    s += Buff[i];
                    i = 0;
                }
                ch = _cin.get();
            }
            if (i != 0)
            {
                Buff[i] = '\0';
                s += Buff[i];
            }
            return _cin;
        }

构造，拷贝构造，析构

string(const char* str = "")
            :_size(strlen(str))
            ,_capacity(_size)
        {
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }
        string(const string& s)
        {
            _str = new char[_capacity + 1];
            strcpy(_str, s._str);
            _size = s._size;
            _capacity = s._capacity;
        }
        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;
            _str = nullptr;
            _size = _capacity = 0;
        }

迭代器

iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }

增删查改

void push_back(char c)
        {
            if (_size == _capacity)
                reserve(_capacity = 0 ? 4 : 2 * _capacity);
            _str[_size++] = c;
            _str[_size] = '\0';
        }
        string& operator+=(char c)
        {
            push_back(c);
            return *this;
        }
        void append(const char* str)
        {
            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                reserve(_size + len);
            }
            strcpy(_str + _size, _str);
            _size += len;
        }
        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }
        void clear()
        {
            _str[0] = '\0';
            _size = 0;
        }
        void swap(string& s)
        {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }
        const char* c_str()const
        {
            return _str;
        }
         // 返回c在string中第一次出现的位置
        size_t find(char c, size_t pos = 0) const
        {
            assert(pos < _size);
            for (size_t i = pos; i < _size; i++)
                if (_str[i] == c)
                    return i;
        }
        // 返回子串s在string中第一次出现的位置
        size_t find(const char* s, size_t pos = 0) const
        {
            const char* ans = strstr(_str + _size, s);
            if (ans)
            {
                return ans - _str;
            }
            else {
                return npos;
            }
        }
        // 在pos位置上插入字符c/字符串str，并返回该字符的
        string& insert(size_t pos, char c)
        {
            if (_size == _capacity)
                reserve(_capacity == 0 ? 4 : 2 * _capacity);
            size_t end = _size + 1;
            while (end > pos)
            {
                _str[end] = _str[end - 1];
                --end;
            }
            _str[pos] = c;
            _size++;
        }
        string& insert(size_t pos, const char* str)
        {
            assert(pos <= _size);
            size_t len = strlen(str);
            if (_size == _capacity)
                reserve(_size + len);
            int end = _size;
            while (end >= (int)pos)
            {
                _str[end + len] = _str[end];
                --end;
            }
            strncpy(_str + pos, str, len);
            _size += len;
        }
        // 删除pos位置上的元素，并返回该元素的下一个位置
        string& erase(size_t pos, size_t len)
        {
            assert(pos < _size);
            if (len == npos || pos + len > _size)
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else {
                size_t begin = pos + len;
                while (begin <= _size)
                {
                    _str[begin - len] = _str[begin];
                    ++begin;
                }
                _size -= len;
            }
        }

访问

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

运算符重载

bool operator<(const string& s)
        {
            return strcmp(_str, s._str) < 0;
        }
        bool operator<=(const string& s)
        {
            return _str < s._str || _str == s._str;
        }
        bool operator>(const string& s)
        {
            return strcmp(_str, s._str) > 0;
        }
        bool operator>=(const string& s)
        {
            return _str > s._str || _str == s._str;
        }
        bool operator==(const string& s)
        {
            return _str == s._str;
        }
        bool operator!=(const string& s)
        {
            return !(_str == s._str);
        }

总体代码

#include <iostream>
#include <cassert>
using namespace std;

namespace zx
{
    class string
    {
        friend ostream& operator<<(ostream& _cout, const zx::string& s)
        {
            for (size_t i = 0; i < s._size; i++)
            {
                _cout << s._str[i];
            }
            return _cout;
        }
        friend istream& operator>>(istream& _cin, zx::string& s)
        {
            s.clear();
            char Buff[129];
            size_t i = 0;
            char ch;
            ch = _cin.get();
            while (ch != ' ' && ch != '\n')
            {
                Buff[i++] = ch;
                if (i == 128)
                {
                    Buff[i] = '\0';
                    s += Buff[i];
                    i = 0;
                }
                ch = _cin.get();
            }
            if (i != 0)
            {
                Buff[i] = '\0';
                s += Buff[i];
            }
            return _cin;
        }
    public:
        typedef char* iterator;
    public:
        string(const char* str = "")
            :_size(strlen(str))
            ,_capacity(_size)
        {
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }
        string(const string& s)
        {
            _str = new char[_capacity + 1];
            strcpy(_str, s._str);
            _size = s._size;
            _capacity = s._capacity;
        }
        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;
            _str = nullptr;
            _size = _capacity = 0;
        }
        //
        // iterator
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }
        
        // modify
        void push_back(char c)
        {
            if (_size == _capacity)
                reserve(_capacity = 0 ? 4 : 2 * _capacity);
            _str[_size++] = c;
            _str[_size] = '\0';
        }
        string& operator+=(char c)
        {
            push_back(c);
            return *this;
        }
        void append(const char* str)
        {
            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                reserve(_size + len);
            }
            strcpy(_str + _size, _str);
            _size += len;
        }
        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }
        void clear()
        {
            _str[0] = '\0';
            _size = 0;
        }
        void swap(string& s)
        {
            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }
        const char* c_str()const
        {
            return _str;
        }
        
        // capacity
        size_t size()const
        {
            return _size;
        }
        size_t capacity()const
        {
            return _capacity;
        }
        bool empty()const
        {
            return _size == 0;
        }
        void resize(size_t n, char c = '\0')
        {
            if (n < _size)
            {
                _str[n] = '\0';
                _size = n;
            }
            else {
                reserve(n);
                while (_size < n)
                {
                    _str[_size] = n;
                    _size++;
                }
                _str[_size] = '\0';
            }
        }
        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n+1];
                strcpy(tmp, _str);
                delete[]_str;
                _str = tmp;
                _capacity = n;
            }
        }
        /
        // access
        char& operator[](size_t index)
        {
            assert(index < _size);
            return _str[index];
        }
        const char& operator[](size_t index)const
        {
            assert(index < _size);
            return _str[index];
        }
        /
        //relational operators
        bool operator<(const string& s)
        {
            return strcmp(_str, s._str) < 0;
        }
        bool operator<=(const string& s)
        {
            return _str < s._str || _str == s._str;
        }
        bool operator>(const string& s)
        {
            return strcmp(_str, s._str) > 0;
        }
        bool operator>=(const string& s)
        {
            return _str > s._str || _str == s._str;
        }
        bool operator==(const string& s)
        {
            return _str == s._str;
        }
        bool operator!=(const string& s)
        {
            return !(_str == s._str);
        }
        // 返回c在string中第一次出现的位置
        size_t find(char c, size_t pos = 0) const
        {
            assert(pos < _size);
            for (size_t i = pos; i < _size; i++)
                if (_str[i] == c)
                    return i;
        }
        // 返回子串s在string中第一次出现的位置
        size_t find(const char* s, size_t pos = 0) const
        {
            const char* ans = strstr(_str + _size, s);
            if (ans)
            {
                return ans - _str;
            }
            else {
                return npos;
            }
        }
        // 在pos位置上插入字符c/字符串str，并返回该字符的
        string& insert(size_t pos, char c)
        {
            if (_size == _capacity)
                reserve(_capacity == 0 ? 4 : 2 * _capacity);
            size_t end = _size + 1;
            while (end > pos)
            {
                _str[end] = _str[end - 1];
                --end;
            }
            _str[pos] = c;
            _size++;
        }
        string& insert(size_t pos, const char* str)
        {
            assert(pos <= _size);
            size_t len = strlen(str);
            if (_size == _capacity)
                reserve(_size + len);
            int end = _size;
            while (end >= (int)pos)
            {
                _str[end + len] = _str[end];
                --end;
            }
            strncpy(_str + pos, str, len);
            _size += len;
        }
        // 删除pos位置上的元素，并返回该元素的下一个位置
        string& erase(size_t pos, size_t len)
        {
            assert(pos < _size);
            if (len == npos || pos + len > _size)
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else {
                size_t begin = pos + len;
                while (begin <= _size)
                {
                    _str[begin - len] = _str[begin];
                    ++begin;
                }
                _size -= len;
            }
        }
    private:
        char* _str;
        size_t _size;
        size_t _capacity;
        const static size_t npos = -1;
    };
}
C++无所不及
关注
专栏目录
模拟实现string以及一些接口
02-27
模拟实现string以及一些接口
String各个接口模拟实现
08-27
String各个接口模拟实现
string的模拟实现
2401_83427936的博客
07-09 2033
分情况：//resize的模拟实现,可以删除数据，也可以扩容,不缩容,当_capacity为15，_size为10时。//resize(8)就是删除数据(删除两个),resize(12)就是插入数据,resize(18)就是扩容。15find的模拟实现,从pos位置找一个字符,返回下标位置。14erase的模拟实现,pos位置后删除len个字符。12insert的模拟实现,pos位置插入字符串。20resize的模拟实现,可以删除数据。16find的模拟实现,找字符串。30>>的模拟实现,流插。
【C++】string模拟实现
2303_79329831的博客
05-18 1929
本篇博客主要内容：实现string类的基本功能。string使用很快就讲完了，但是光会用string还不够，在面试中，面试官总喜欢让我们自己来模拟实现string类，包括string类的构造、拷贝构造、赋值运算符重载以及析构函数等等内容。所以，我认为string类的自实现还是有必要讲一下的。本篇博客主要介绍了string类常用接口的实现，包括默认成员函数，迭代器，字符和字符串的插入删除等等内容。♥STLC++
C++ [STL之string模拟实现]
ARMCSKGT的博客
05-19 5692
前面我们介绍了STL容器string的部分接口使用，有了string使我们对字符串的操作如鱼得水，其实string不止于使用方便，其实现也有许多我们值得学习的地方，本节将为您介绍string常用接口的代码实现！
⚡【C++要笑着学】(17) 模拟实现 string：深浅拷贝 | string 模拟实现 | 传统写法与现代写法
有道无术, 术尚可求。有术无道, 止于术。
05-07 4459
本章将正式介绍深浅拷贝，在模拟实现 string 的同时带着去理解深浅拷贝。我们模拟实现 string类不是为了造更好的轮子，而是为了去学习它，理解它的本质！你自己造一次，心里会更清楚，也有利于加深对 string 的理解。...
『C++成长记』string模拟实现
小王又困了的博客
07-08 2769
本篇我们将为大家介绍string常用接口的模拟实现。
【C++初阶】string模拟实现
weixin_74967884的博客
05-13 2030
本章节详细的讲解了string模拟实现。
c++模拟实现string类
北川_的博客
01-11 1875
目录string类简介模拟实现成员变量成员函数构造函数拷贝构造赋值重载析构函数迭代器普通迭代器const迭代器重载运算符[ ]代码 string类简介 标准库类型string表示可变长的字符序列，使用string类型必须首先包含string头文件。作为标准库的一部分，string定义在命名空间std中。 模拟实现 成员变量 char* _str; size_t _size; size_t _capacity; //不包含最后做标识的'\0' static const size_t npos; _s
【C++】STL-string模拟实现
chuxinchangcun的博客
12-22 6083
public:string是一个管理字符数组的类,要求这个字符数组结尾用\0标识1.拷贝构造和赋值重载实现深拷贝2.增删查找的相关接口(跟顺序表类似)3.重载了一些常见的运算符 如: > < >> 加const2.只写接口函数 ->不加const3.可读可写接口函数 ->分为加const版本和不加const版本。
【C++】string的模拟实现
学了就忘是正常现象
11-16 2769
C++中string类的模拟实现。
模拟实现string类
weixin_58867976的博客
03-10 4118
目录 前言 一、初始准备 二、迭代器 三、构造函数 四、赋值运算符重载 五、插入字符及字符串 六、查找字符及字符串 七、删除字符或字符串 八、重载关系运算符 九、重载+=运算符 十、析构函数 十一、重载输入输出运算符 十二、全部代码 前言 由于string类的接口函数很多，所以这里只实现常用的接口函数 部分很简单的接口函数，都放在代码段里了 一、初始准备 引用头文件 引用string的头文件，是为了后面写接口函数，需要调用字符串函数，比如strstr，strcpy等
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中String类模拟实现以及深拷贝浅拷贝
08-28
然而，为了更好地理解这一封装的实现原理，开发者有时需要模拟实现一个String类。在这模拟实现的过程中，必须处理深拷贝（deep copy）和浅拷贝（shallow copy）的问题。 浅拷贝在对象复制时，仅仅是复制了对象的...
34. 在排序数组中查找元素的第一个和最后一个位置
weixin_61695887的博客
10-12 493
请你找出给定目标值在数组中的开始位置和结束位置。给你一个按照非递减顺序排列的整数数组。你必须设计并实现时间复杂度为。如果数组中不存在目标值。
图算法之Floyd-Warshall 算法（全点对最短路径）详细解读
m0_61840987的博客
10-11 802
Floyd-Warshall 算法是求解全点对最短路径的经典算法，适用于需要处理负权边的场景。它的时间复杂度较高，因此适合处理顶点较少的密集图，而不是稀疏图。如果图中存在负权环，该算法可以用来检测。
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 148
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 357
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值