【c++】模拟实现string类__实现增删查改

代码如下：

String.h文件

#pragma once

#include<iostream>
#include<assert.h>
using namespace std;
class String
{
public:
    String(const char* str = "")//构造函数
    {
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
        _Size = strlen(str);
        _Capacity = _Size+1;
    }
    String(const String& s)//拷贝构造----传统写法
    {
        _str = new char[strlen(s._str) + 1];
        strcpy(_str, s._str);
        _Size = s._Size;
        _Capacity = s._Capacity;
    }
        /*String(const String& s)//拷贝构造---现代写法1
        {
        String tmp(s._str);
        swap(_str, tmp._str);
        _Size = s._Size;
        _Capacity = s._Capacity;
        }*/
    String& operator=(const String& s)//运算符重载---s1=s2
    {
        if (this != &s)
        {
            delete[] _str;
            _str = new char[strlen(s._str) + 1];
            strcpy(_str, s._str);
            _Size = s._Size;
            _Capacity = s._Capacity;
        }
        return *this;
    }
    ~String()//析构函数
    {
        if (_str)
        {
            delete[] _str;
            _str = NULL;
            _Size = 0;
            _Capacity = 0;
        }
    }

    char* GetStr()
    {
        return _str;
    }
    size_t Size()
    {
        return strlen(_str);
    }
    size_t Capacity()
    {
        return _Size;
    }

    // 增删查改 
    void PushBack(char ch);
    void PushBack(const char* str);
    void PopBack();
    void PushFront(char ch);
    void Insert(size_t pos, char ch);
    void Insert(size_t pos, const char* str);
    void Erase(size_t pos, size_t count);
    size_t Find(char ch) const;
    size_t Find(const char* str) const;
    char& operator[](size_t pos);
    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;
    void CheckCapacity(size_t size);
private:
    char* _str;
    size_t _Size;
    size_t _Capacity;
};
//*********************类外*******************

void String::PushBack(char ch)//尾插一个字符
{
    CheckCapacity(_Size);//_Size表示最后一个字符的下一个位置的下标，大小是strlen求得的，不包括‘\0’,所以+2才正确表示
    _str[_Size] = ch;
    ++_Size;
    _str[_Size] = '\0';
}
void String::PushBack(const char* str)//尾插一个字符串
{
    CheckCapacity(_Size + strlen(str));
    for (size_t i = 0; i <= strlen(str); i++)
    {
        _str[_Size] = str[i];
        _Size++;
    }
    _str[_Size] = '\0';
}
void String::PopBack()//尾删
{
    if (_str == NULL)
    {
        return;
    }
    _str[_Size - 2] = _str[_Size-1];
    --_Size;
}
void String::PushFront(char ch)//头插一个字符
{
    CheckCapacity(_Size + 2);
    for (int i = _Size; i >= 0; i--)
    {
        _str[i + 1] = _str[i];
    }
    _str[0] = ch;
    ++_Size;
}
void String::Insert(size_t pos, char ch)//指定位置插入一个字符
{
        CheckCapacity(_Size);
        for (int end = _Size; end >= pos; --end)
        {
            _str[end + 1] = _str[end];
        }
        _str[pos] = ch;
        ++_Size;
}
void String::Insert(size_t pos, const char* str)//指定位置插入一个字符串
{
    if (_str == NULL || str == NULL)
    {
        return;
    }
    if (pos >= 0 && pos <= strlen(_str))
    {
        int len = strlen(str);
        CheckCapacity(_Size + strlen(str));
        for (int end = _Size; end >=(int)pos; --end)
        {
            _str[end + strlen(str)] = _str[end];
        }
        while (*str)
        {
            _str[pos++] = *str++;
        }
        _Size +=len;
    }
}
void String::Erase(size_t pos, size_t count)
{
    assert(pos < strlen(_str));
    //情况一：从pos开始，后面删完了
    //情况二：从pos开始，后面删了一部分
    int len = _Size - pos;//len是从pos之后字符的个数
    if (count >= len)//情况一
    {
        _str[pos] = '\0';
        _Size = pos;
    }
    else//情况二
    {
        strcpy(_str + pos, _str + pos + count);
        _Size = _Size - count;
        //int begin = pos + count;//开始挪动的位置
        //while (_str[begin])
        //{
        //  _str[pos++] = _str[begin];
        //  ++begin;
        //}
        //_Size = _Size - count;
        //_str[_Size] = '\0';
    }
}
size_t String::Find(char ch) const//查找一个字符出现的位置
{
    assert(_str);
    for (int i = 0; i <= _Size; ++i)
    {
        if (_str[i] == ch)
        {
            return i;
        }
    }
    return -1;
}
size_t String::Find(const char* str) const//查找一个字符串出现的位置
{
    assert(str || _str);
    char* str1 = _str;
    char* str2 = (char*)str;
    int pos = 1;
    while (*str1)
    {
        while (*str1 == *str2)
        {
            str1++;
            str2++;
        }
        if (*str2 == NULL)
        {
            return pos;
        }
        str1++;
        pos++;
    }
    return -1;
}
//*************运算符重载*************
char& String::operator[](size_t pos)
{
    return _str[pos];
}
bool String::operator<(const String& s) const
{
    char* str1 = _str;
    char* str2 = s._str;
    while (str1&&s._str)
    {
        if (*str1 < *str2)
        {
            return true;
        }
        if (*str1>*str2)
        {
            return false;
        }
        else
        {
            str1++;
            str2++;
        }
        if (*str1)
        {
            return false;
        }
        if (*str2)
        {
            return true;
        }
    }
}
bool String::operator<=(const String& s) const
{
    return (_str < s._str) || (_str == s._str);
}
bool String::operator==(const String& s) const
{
    char* str1 = _str;
    char* str2 = s._str;
    while (*str1&&str2)
    {
        if (*str1 == *str2)
        {
            str1++;
            str2++;
        }
        else
        {
            return false;
        }
    }
    if (*str1 || *str2)
        {
            return false;
        }
    return true;
}
bool String::operator>(const String& s) const
{
    return !(_str <= s._str);
}
bool String::operator>=(const String& s) const
{
    return (_str > s._str) || (_str == s._str);
}
bool String::operator!=(const String& s)const
{
    return !(_str == s._str);
}


void String::CheckCapacity(size_t size)
{
    if ((size + 1) >= _Capacity)
    {
        _Capacity = size > _Capacity * 2 ? size : _Capacity * 2;
        _str = (char*)realloc(_str, sizeof(char)*_Capacity);
    }
}
void test1()
{
    String s1("Hello ");
    s1.PushBack("world!");
    s1.PushBack('!');
    //s1.PushFront('!');
    s1.PopBack();
    //s1.Insert(0, "world!");
    cout << s1.GetStr()<< endl;
    cout << s1.Size() << endl;
}
void test2()
{
    String s1("Hello ");
    //s1.PushBack('!');
    //s1.PushBack('w');
    //s1.PushBack('o');
    //s1.PushBack('r');
    //s1.PushBack('l');
    //s1.PushBack('d');
    //s1.PushBack('!');
    //s1.PopBack();
    s1.PushBack("world!");
    //s1.PopBack();
    //s1.PopBack();
    //s1.PopBack();
    cout << s1.GetStr() << endl;
    cout << s1.Size() << endl;
}
void test3()
{
    String s1("hello !");
    s1.Insert(7, "world");
    s1.Insert(11, '!');
    //s1.Erase(5, 13);
    cout << s1.GetStr() << endl;
    cout << s1.Size() << endl;
}
void test4()
{
    String s1("hello world!");
    int i = s1.Find("llok");
    cout << i << endl;
}
void test5()
{
    String s1("hello ");
    //s1[1] = 'w';
    cout << s1.GetStr() << endl;
    cout << s1[1] << endl;
}
void test6()
{
    String s1("hello");
    String s2("hel0");
    cout << (s1 == s2) << endl;
    cout << true << endl;
}

主函数：

#define _CRT_SECURE_NO_WARNINGS 1

#include"String.h"

int main()
{
    //test1();
    //test2();
    test3();
    //test4();
    //test5();
    //test6();
    system("pause");
    return 0;
}