【C++】string100%模拟实现

最新推荐文章于 2022-08-04 19:38:28 发布
最新推荐文章于 2022-08-04 19:38:28 发布
阅读量271 收藏
点赞数 1
分类专栏： c++ 文章标签： string模拟实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yulong__li/article/details/84880623
版权

断断续续写了好几天，，写了800多行。本来只需要把常用的接口会用就可以了，但是我觉得能把string里面的接口自己实现一遍，那么string就基本熟悉了。

就不解释了，望共勉之！

#include<climits>
#include<vector>
#include <iostream>
#include<assert.h>
#include<string.h>
using namespace std;


class String
{
public:
    typedef char* Iterator;
    typedef const char* const_Iterator;
    构造对象/
    //用一个字符串构造对象
    String()
        : _capacity(10)
        , _size(0)
    {
        _str = new char[_capacity + 1];
    }

    String(const char* str)
        :_capacity(strlen(str))
        ,_size(_capacity)
    {
        if(nullptr == str)
            str = " ";
        _str = new char[_size + 1];
        strcpy(_str, str);
    }

    //用一个字符串前n个字符构造对象
    String(const char* str, size_t n)
    {
        assert(str);
        size_t len = strlen(str);
        if(n > len)
            n = len;

        _str = new char[n + 1];
        memcpy(_str, str, n);

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

    String(const String& s, size_t pos, size_t n = npos)
    {
        assert(pos < _size);
        size_t len = strlen(s._str) - pos;
        if((int)n == -1)
            n = len;
        if(n > len)
            n = len;
        _str = new char[n + 1];

        memcpy(_str, s._str + pos, n);

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

    String(size_t n, char c)
        :_capacity(n)
        ,_size(0)
    {
        _str = new char[_capacity + 1];
        while(_size <= _capacity)
            _str[_size++] = c;
    }
    //拷贝构造函数
    String(const String& s)
        : _str(new char[s._size + 1])
        , _capacity(s._size)
        , _size(s._size)
    {
        strcpy(_str, s._str);
    }
    //运算符重载
    String& operator=(const String& s)
    {
        if(this != &s)
        {
            char* pstr = new char[s._capacity + 1];
            strcpy(pstr, s._str);
            delete[] _str;
            _str = pstr;
            _capacity = s._capacity;
            _size = s._size;
        }

        return *this;
    }


    //析构函数
    ~String()
    {
        if(_str)
        {
            delete[] _str;
            _str = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }
    Iterator//
    
    Iterator Begin()
    {
        return _str;
    }

    const_Iterator Begin()const
    {
        return _str;
    }
    
    Iterator End()
    {
        return _str + _size;
    }

    const_Iterator End()const
    {
        return _str + _size;
    }

    Iterator rBegin()
    {
        return End();
    }

    Iterator rEnd()
    {
        return Begin();
    }

    ///Capacity
    
    size_t Size() const
    {
        return _size;
    }

    size_t Length() const
    {
        return _size;
    }

    size_t Max_Size()const
    {
        string s;
        return s.max_size();
    }
    
    void Resize(size_t n, char c = '0')
    {
        if(n <= _size)
        {
            _size = n;
        }
        else
        {
            if(n > _size)
            {
                char* pstr = new char[2 * n + 1];
                strcpy(pstr, _str);
                delete[] _str;
                _str = pstr;
                _capacity = 2 * n;
            }

            memset(_str+_size,c,n-_size);
            _size = n;
        }
        _str[_size] = '\0';
    }
    
    size_t Capacity()const
    {
        return _capacity;
    }

    void Reserve(size_t res_arg = 0)
    {
        if(res_arg > _capacity)
        {
            char* pstr = new char[res_arg + 1];
            strcpy(pstr, _str);
            
            delete[] _str;
            _str = pstr;
            _capacity = res_arg;
        }
    }
    
    void Clear()
    {
        _size = 0;
        _str[0] = '\0';
    }

    bool Empty()
    {
        return 0 == _size;
    }


///元素访问

    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)
    {
        if(strcmp(_str, s._str) > 0)
            return true;
        return false;
    }

    bool operator<(const String& s)
    {
        if(strcmp(_str, s._str) < 0)
            return true;
        return false;
    }

    bool operator>=(const String& s)
    {
        if(strcmp(_str, s._str) >= 0)
            return true;
        return false;
    }

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

    bool operator==(const String& s)
    {
        if(strcmp(_str, s._str) == 0)
            return true;
        return false;
    }

    bool operator!=(const String& s)
    {
        if(strcmp(_str, s._str) != 0)
            return true;
        return false;
    }


    friend ostream& operator<<(ostream& _cout, const String& s)
    {
        _cout << s._str;
        return _cout;
    }

    friend istream& operator>>(istream& _cin, const String& s)
    {
        _cin >> s._str;
        return _cin;
    }
    /对象修改操作/
    
    String& operator+=(char c)
    {
        PushBack(c);
        return *this;
    }

    String& operator+=(const String& s)
    {
        if(s._size > _capacity - _size)
            Reserve(s._size + _capacity * 2);
        strcat(_str,s._str);
        _size += s._size;

        return *this;
    }

    String& operator+=(const char* str)
    {
        size_t len = strlen(str);
        if(len > _capacity - _size)
            Reserve(len + _capacity * 2);

        strcat(_str, str);
        _size += len;
        
        return *this;
    }

    void PushBack(char c)
    {
        
        if(_size == _capacity)
            Reserve(_capacity * 1.5);
        _str[_size++] = c;
        _str[_size] = '\0';
    }

    void PopBack()
    {
        _size--;
    }
    
    void Insert(Iterator p, size_t n, char c)
    {
        String temp;
        for(Iterator it = Begin(); it < End(); it++)
        {
            if(it == p)
            {
                while(n--)
                {
                    temp += c;
                }
                temp += *it;
            }
            else
                temp += *it;
        }
        this->Clear();
        *this = temp;
    }

    Iterator Insert ( Iterator p, char c  )
    {
        if(_size +1 == _capacity)
            Reserve(_capacity * 1.5);
        for(Iterator it = End(); it >= p; --it)
        {
            *(it + 1) = *it;
        }
        *p = c;
        return Begin();
    }

    String& Insert(size_t pos1, size_t n, char c)
    {
        String temp;
        for(size_t i = 0; i < _size; ++i)
        {
            if(pos1 == i)
            {
                while(n--)
                {
                    temp += c;
                }
                temp += _str[i];
            }
            else
                temp += _str[i];
        }
            this->Clear();
            *this = temp;
            return *this;
            
    }

    String& Insert(size_t pos1, const char* str)
    {
        String temp;
        for(size_t i = 0; i < _size; ++i)
        {
            if(i == pos1)
            {
                temp += str;
                temp += _str[i];
            }
            else
                temp += _str[i];
        }
        
        return *this = temp;
    }

    String& Insert ( size_t pos1, const char* s, size_t n )
    {
        String temp;
        for(size_t i = 0; i < _size; ++i)
        {
            if(i == pos1)
            {
                size_t j = 0;
                while(n--)
                    temp += s[j++];
                temp += _str[i];
            }
            else
                temp += _str[i];
        }
        return *this = temp;
    }


    String& Insert ( size_t pos1, const String& s  )
    {
        String temp;
        for(size_t i =0; i < _size; ++i)
        {
            if(i == pos1)
            {
                temp += s;
                temp += _str[i];
            }
            else
                temp += _str[i];
        }
        return *this = temp;
    }



    String& Insert ( size_t pos1, const String& s, size_t pos2, size_t n)
    {
        String temp;
        String sub;
        sub = s.Substr(pos2, n);
        for(size_t i =0;i< _size; ++i)
        {
            if(i == pos1)
            {
                temp += sub;
                temp += _str[i];
            }
            else
                temp += _str[i];
        }
        return *this = temp;
    }

    String& Erase ( size_t pos = 0, size_t n = npos  )
    {
        assert(pos < _size);
        if(n > _size - pos)
        {
            n = _size - pos;
            _str[pos] = '\0';
            _size = pos;
            return *this;
        }
        else
        {
            for(size_t i = pos; i <_size - n; ++i)
            {
                _str[i] = _str[i + n];
            }
            _str[_size - n] = '\0'; 
            _size -= n;
            return *this;
        }
    }


    Iterator Erase ( Iterator position  )
    {
        assert(position < End());
        for(Iterator it = position; it < End(); it++)
            *it = *(it + 1);
        _size--;
        return Begin();
    }

    //[first, last]
    Iterator Erase ( Iterator first, Iterator last  )
    {
        assert(first < last);
        size_t n = last - first + 1; 
        for(Iterator it = first;it <= End()- n; it++)
            *it = *(it + n);
        _size -= n;
        return Begin();
    }


    String& Append(const String& s)
    {
        *this += s;
        return *this;
    }

    String& Append(const String& s, size_t pos, size_t n)
    {
        String pstr = s.Substr(pos,n);
        *this += pstr;
        return *this;
    }

    String& Append(const char* str, size_t n)
    {
        size_t len = strlen(str);
        if(n > len)
            n = len;
        if(n > _capacity - _size)
            Reserve(n + _capacity * 1.5);
        memcpy(_str + _size, str, n);

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

    String& Append(const char* str)
    {
        *this += str;
        return *this;
    }

    String& Append(size_t n, char c)
    {
        while(--n)
            PushBack(c);
        return *this;
    }



    String& Assign ( const String& s)
    {
        if(_capacity < s._capacity)
        {
            char* temp = new char[s._capacity + 1];
            strcpy(temp, s._str);
            delete[] _str;
            _str = temp;
            _size = s._size;
            _capacity = s._capacity;
        }
        else
        {
            strcpy(_str, s._str);
            _size = s._size;
        }
        return *this;
    }

    String& Assign ( const String& s, size_t pos, size_t n  )
    {
        String temp = s.Substr(pos, n);
        Assign(temp);
        return *this;
    }

    String& Assign ( const char* s, size_t n  )
    {
        String temp(s);
        temp = temp.Substr(0,n);
        Assign(temp);
        return *this;
    }

    String& Assign ( const char* s  )
    {
        String temp(s);
        Assign(temp);
        return *this;
    }

    String& Assign ( size_t n, char c  )
    {
        Clear();
        while(n--)
        {
            PushBack(c);
        }

        return *this;
    }

    
    String& Replace ( size_t pos1, size_t n1,const String& s)
    {
        Erase(pos1, n1);
        Insert(pos1, s);
        return *this;
    }

    String& Replace(Iterator i1, Iterator i2, const String& s)
    {
        Erase(i1, i2);
        size_t pos = i1 - Begin();
        Insert(pos,s);
        return *this;
    }

    String& Replace (size_t pos1, size_t n1, const String& s, size_t pos2, size_t n2)
    {
        Erase(pos1, n1);
        String temp = s.Substr(pos2, n2);
        Insert(pos1, temp);
        return *this;
    }

    String& Replace (size_t pos1, size_t n1,const char* str, size_t n2)
    {
        Erase(pos1, n1);
        Insert(pos1, str, n2);
        return *this;
    }

    String& Replace (Iterator i1, Iterator i2, const char* str, size_t n2)
    {
        Erase(i1, i2);
        size_t pos = i1 - Begin();
        Insert(pos, str, n2);
        return *this;
    }


    String& Replace (size_t pos1, size_t n1,   const char* str)
    {
        Erase(pos1, n1);
        Insert(pos1,str);
        return *this;
    }
    String& Replace ( Iterator i1, Iterator i2, const char* str)
    {
        Erase(i1, i2);
        size_t pos = i1 - Begin();
        Insert(pos,str);
        return *this;
    }
    String& Replace ( size_t pos1, size_t n1,   size_t n2, char c  )
    {
        Erase(pos1, n1);
        Insert(pos1, n2, c);
        return *this;
    }
    String& Replace ( Iterator i1, Iterator i2, size_t n2, char c  )
    {
        Erase(i1, i2);
        size_t pos = i1 -Begin();
        Insert(pos, n2, c);
        return *this;
    }

    

    void Swap(String& s)
    {
        swap(_str, s._str);
        swap(_size, s._size);
        swap(_capacity, s._capacity);
    }
//字符串操作//
    
    
    const char* C_str()const
    {
        return _str;
    }

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

    size_t Copy(char* s, size_t n, size_t pos = 0)
    {
        assert(pos < _size);
        if(n > _size - pos)
            n = _size - pos;
        size_t j = 0;
        for(size_t i = pos; i < pos + n; ++i)
            s[j++] = _str[i];
        return n;
    }

    
    size_t Find ( const String& s, size_t pos = 0  ) const
    {
        assert(pos < _size);
        if(char* index = strstr(_str+pos, s._str))
            return index - Begin();
        return npos;
            
    }
    size_t Find( const char* str, size_t pos, size_t n  ) const
    {
        assert(pos < _size);
        if(n > strlen(str))
            n = strlen(str);
        String temp(str);
        temp = temp.Substr(0,n);
        if(char* index = strstr(_str+pos, temp._str))
            return index - Begin();
        return npos;
    }
    size_t Find ( const char* s, size_t pos = 0  ) const
    {
        
        assert(pos < _size);
        if(char* index = strstr(_str+pos, s))
            return index - Begin();
        return npos;
            
    }


    size_t Find(char c, size_t pos = 0)const 
    {
        for(size_t i = pos; i < _size; ++i)
        {
            if(c == _str[i])
                return i;
        }

        return npos;
    }

    size_t Rfind ( const String& s, size_t pos = npos  ) const;
    size_t Rfind ( const char* str, size_t pos, size_t n  ) const;
    size_t Rfind ( const char* str, size_t pos = npos  ) const;

    size_t Rfind ( char c, size_t pos = npos  ) const
    {
        if(pos > _size -1)
            pos = _size -1;
        for(int i = pos; i >= 0; --i)
        {
            if(_str[i] == c)
                return i;
        }

        return npos;
    }



    String Substr(size_t pos = 0, size_t n = npos)const
    {
        size_t len = strlen(_str + pos);
        if(n > len)
            n = len;
        return String(_str + pos, n);

    }

    int Compare ( const String& s  ) const
    {
        const_Iterator it1 = Begin(); 
        const_Iterator it2 = s.Begin();
        while(*it1 == *it2 && *it1&&*it2)
        {
            if(*it1 == '\0' || *it2 == '\0')
                return 0;
            it1++;
            it2++;
        }
        if(*it1 > *it2)
            return 1;
        if(*it1 < *it2)
            return -1;
    }
    int Compare ( const char* s  ) const
    {
        return strcmp(_str, s);
    }
    int Compare ( size_t pos1, size_t n1, const String& s  ) const
    {
        String temp = Substr(pos1, n1);
        return strcmp(temp._str,s._str);
    }
    int Compare ( size_t pos1, size_t n1, const char* s ) const
    {

        String temp = Substr(pos1, n1);
        return strcmp(temp._str,s);
    }
    int Compare ( size_t pos1, size_t n1, const String& s, size_t pos2, size_t n2  ) const
    {
        String temp1 = Substr(pos1, n1);
        String temp2 = s.Substr(pos2, n2);
        return strcmp(temp1._str, temp2._str);
    }
    int Compare ( size_t pos1, size_t n1, const char* s, size_t n2 ) const
    {
        String temp1 = Substr(pos1, n1);
        String temp2(s, n2);
        return strcmp(temp1._str, temp2._str);
    }
private:
    char* _str;
    size_t _capacity;
    size_t _size;
    static const size_t npos;
};

const size_t String::npos = -1;


int main()
{
    String s1("hello world i love you");
    String s2("hello");
    cout << s2.Compare(0,5,"hello world", 5)<<endl;
    
    return 0;

}

 

神化我
关注
专栏目录
C++中的模拟class string类的代码 cpp
08-02
//一个C++初学者的string类，恳请朋友们多多指点 //特殊功能：- 取负数运算符代表将字符串翻转 函数头： class string{ friend int len(string &); friend const string & operator+(const string &s1,const string &s2); friend std::ostream & operator<<(std::ostream &theStream,const string & str); friend const string & operator+(const string &s1,const char * s2); friend const string & operator+(const char * s2,const string &s1); private: int itslen; public: string(); string(int length); string(string & str); string(const char *str); const string & operator=(const char str[]); const string & operator+=(const char str[]); const string & operator-()const; const char & operator[](int index) const; operator char*() const; char & operator[](const int index); ~string(); void put(); char *inner; operator int()const; };
C++ string类的模拟实现
最新发布
08-11
C++ string类的模拟实现
模拟实现string
Calm的博客
07-05 368
1.初始化成员列表高效在哪里 对类类型来说，用初始化列表少了一次调用默认构造函数的过程，这对于数据密集型的类来说，是非常高效的。 2.形参为const引用的好处 a.当实参的类型比较大时，复制开销很大，引用会“避免复制”。 b.“避免修改实参”，当使用引用时，如果调用者希望只使用实参并不修改实参，则const可以避免使用该引用修改实参。 3.使用&的好处 形参是对象的引用，是通过传地址
string的模拟实现(String)
库蒂尼奥的博客
11-15 643
string的兄弟String一、初始化与清理1.1构造函数1.2析构函数二、运算符重载2.1赋值运算符2.2其他运算符三、迭代器3.1 一、初始化与清理 1.1构造函数 1.2析构函数 二、运算符重载 2.1赋值运算符 2.2其他运算符 三、迭代器 3.1 ......
模拟String类
long0624的博客
05-04 120
#include&lt;string.h&gt; #include&lt;iostream&gt; using namespace std; //普通版 class String { public: String() :_str(new char[1]) { _str = '\0'; } String(char* str = ""...
模拟实现string类
weixin_39384753的博客
07-03 174
模拟实现string类
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
模拟c++的string类
yangrujing的专栏
09-06 764
#include<iostream> #include<assert.h> using namespace std; #pragma warning(disable:4996) #define DEFAULT_CAPACITY 5class String { public: String(const char* str = "") :_str(new char[strlen(
大数乘法（被乘数是string）（乘数在100以内（也可以该））（这样写的很清楚）
longyuan20102011的专栏
11-11 1166
#include #include #include using namespace std; #define MAX 300 char str[MAX]={"43426197"}; void mul(int n) { //转化分两部，第一部反转 char temp[MAX];int i; //这个初始化很重呀，因为后边要乘，这里做是为啦不出现负值 for(i=0;i<MAX;i+
字符串和字符数组
weixin_44395686的博客
10-30 353
字符串和字符数组 C的字符串是通过字符数组来实现的。通过打印字符数组的每个元素来观察字符数组的元素组成和布局： #include <stdio.h> #include <string.h> int main(void) { char string[] = "hello";/* 字符串(字符数组)的长度是5，字符数组的大小是6。虽然空字符不计入字符串长度，但是空字符占一个字节 */ char message[] = {'h', 'e', 'l', 'l', 'o', '\0'};
string的问题
saga20081208的博客
11-17 666
string的问题 最近在工作的过程中，经常会遇到Siemens PLC的string问题，现在大概的梳理一下 目录string的问题 目录 string形式 string的特点 例子 string形式西门子中string的长度是可变的。例如，你可以写string[30]：表示存储三十个char的string，而string[100]则表示是存储100个char的string。string的特点
C++ string 详解
guomeiran的专栏
11-29 491
stringc++insertciterator算法 目录(?)[+]     之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是
int--String
Dingqiang0424的博客
04-27 264
 package com.edu.integer; /**   int和String类型的相互转换：   int -- String  方式1：  String s = 100 +"";  方式2:    String.valueOf(int)  方式3：  Integer.toString(100);     String -- int  方式1：    Int
在C中使用string类输入与输出
qq_38993096的博客
03-24 568
方法一 string str; str.assign(100,'\n'); //这里初始化一个大笑为100的，内容为‘\0'的字符串数组。 scanf("%s",str.c_str()); printf("%s\n",str.c_str()); 方法二 //完成对一个字符串的输入与输出的基本操作 char str[100]; //指定内存大小为100，若输入输出超出内存长度则会报错，提示数组越界...
c++ string 的简单用法
m0_67611983的博客
08-04 1884
近期学习总结
c++string类的模拟实现
04-20
好的，我可以回答这个问题。C++中的string类是一个动态数组，其中包含了一些操作字符串的方法，例如查找、替换、截取等等。为了模拟实现这个类，您...这些都是模拟实现string类的基本步骤。希望这个回答对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值