String类

模拟实现string类：
头文件：

#ifndef _STRING_H__
#define _STRING_H__

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


class String
{
    friend ostream& operator<<(ostream _cout, const String& s);
public:
    //构造函数
    String(const char* str ="");
    String(const String& str);
    //拷贝构造函数
    String& operator=(const String& s);
    //析构函数
    ~String();
public:
    //操作运算符的重载
    char& operator[](size_t index);
    const char& operator[](size_t index)const;
    string operator+(const string& s);
    bool operator==(const String&s);
    bool operator>(const String&s);
    bool operator>=(const String&s);
    bool operator<(const String&s);
    bool operator<=(const String&s);
    bool operator!=(const String&s);
public:
    //尾插一个元素
    void PushBack(char ch);
    //尾插一个字符串
    void Append(const char* str);
    //尾删一个元素
    void PopBack();
    //尾删n个字符
    void PopBackStr(size_t n);
    //头插一个字符
    void PushFront(char ch);
    //头删一个字符
    void PopFront();

    //任意位置指定插入一个字符
    void Insert(size_t pos, char ch);
    //任意位置插入一个字符串
    void Insert(size_t pos, const char* str);
    //任意位置删除一个元素
    void Erase(size_t pos);
    //任意位置删除n个字符
    void Erase(size_t pos, size_t n);

public:
    //扩容
    char* ExpandCapacity(size_t n);
    char* Getstr();
    size_t Size()const;
    void display();
private:
    char* _str;
    size_t _size;
    size_t _capacity;
};


#endif//_STRING_H__

实现函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include"String.h"

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

浅拷贝
浅拷贝会引发同一块内存被释放多次的危险
//String::String(const String& str)
//{
//  _str = str._str;
//_size = strlen(str);
//_capacity = _size;
//}

深拷贝<普通版>
//String::String(const String& str)
//{
//  delete[]_str;
//  _str = new char[strlen(str._str) + 1];
//  strcpy(_str, str._str);
// _size = strlen(str);
//_capacity = _size;
//}

//深拷贝 简洁版
String::String(const String& str)
{
    String s(str._str);
    std::swap(_str, s._str);
    _size = strlen(str._str);
    _capacity = _size;
}

浅拷贝
//String& String::operator=(const String& s)
//{
//  if (this != &s)
//  {
//      _str = s._str;
//  }
//  return *this;
//}

深拷贝 普通版
//String& String::operator=(const String& s)
//{
//  if (this != &s)
//  {
//      delete[]_str;
//      _str = new char[strlen(s._str) + 1];
//      strcpy(_str, s._str);
//      _size = strlen(s._str);
//      _capacity = _size;
//  }
//  return *this;
//}

//深拷贝 简洁版
String& String::operator=(const String& s)
{
    if (this != &s)
    {
        String str(s._str);
        std::swap(_str, str._str);
        _size = strlen(s._str);
        _capacity = _size;
    }
    return *this;
}

String::~String()
{
    if (_str)
    {
        delete[]_str;
        _str = NULL;
    }
}


size_t my_strlen(char* dest)
{
    assert(dest);
    const char* p = dest;
    while (*p++)
    {
        ;
    }
    return (p - dest-1);
}

//求字符串长度
size_t String::Size()const
{
    return _size;
}

//
运算符重载
char& String::operator[](size_t index)
{
    assert(index<Size());
    return _str[index];
}

const char& String::operator[](size_t index)const
{
    assert(index<Size());
    return _str[index];
}
bool String::operator==(const String&s)
{
    size_t index = 0;
    for (index=0; index<s._size && index<s._size; index++)
    {
        if (_str[index] != s._str[index])
        {
            return false;
        }
    }
    if (index==_size && index==s._size)
    {
        return true;
    }
    return false;
}

bool String::operator>(const String&s)
{
    size_t i = 0;
    for (i = 0; ((i < _size) && (i < s._size)); i++)
    {
        if (_str[i] < s._str[i])
        {
            return false;
        }
        else if (_str[i] > s._str[i])
        {
            return true;
        }
    }
    if ((i == s._size) && (i < _size))
    {
        return true;
    }
    return false;
}

bool String::operator>=(const String&s)
{
    return(operator>(s) || operator==(s));
}

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

bool String::operator<=(const String&s)
{
    return((operator<(s)) || (operator==(s)));
}

bool String::operator!=(const String&s)
{
    return (!(operator==(s)));
}

//获取字符串
char* String::Getstr()
{
    return _str;
}

char* String:: ExpandCapacity(size_t n)
{
    char* tmp = new char[n+1];
    strcpy(tmp, _str);
    delete[]_str;
    _str = tmp;
    tmp = NULL;
    return _str;
}

//尾插一个字符串
void String::PushBack(char ch)
{
    if ((_size) == _capacity)
    {
        ExpandCapacity(_capacity * 2);
        _capacity *= 2;
    }
    _str[_size] = ch;
    _size++;
    _str[_size] = '\0';
}

//尾插一个字符串
void String:: Append(const char* str)
{
    size_t len = strlen(str);
    if (len + _size > _capacity)
    {
        ExpandCapacity(len + _size);
        _capacity += len;
    }
    strcpy(_str + _size, str);
    _size += len;
    _capacity += len;
}

//尾删一个字符
void String:: PopBack()
{
    assert(_size);
    _str[_size-1] = '\0';
    _size--;
}

//尾部删除n个字符
void String:: PopBackStr(size_t n)
{
    if (n > _size)
    {
        _str[0] = '\0';
        _size = 0;
    }
    else
    {
        _str[_size - n - 1] = '\0';
        _size -= n;
    }
}

//头插一个字符
void String:: PushFront(char ch)
{
    if (_size == _capacity)
    {
        ExpandCapacity(_capacity * 2);
        _capacity *= 2;
    }
    for (size_t i = 0; i <= _size; i++)
    {
        _str[_size+1-i] = _str[_size-i];
    }
    _str[0] = ch;
    _size++;
}

//头删一个字符
void String:: PopFront()
{
    for (size_t i = 0; i < _size; i++)
    {
        _str[i] = _str[i + 1];
    }
    _size--;
}

//任意位置指定插入一个字符
void String:: Insert(size_t pos, char ch)
{
    if (pos<0 || pos>_size)
    {
        return;
    }
    for (size_t i = 0; i <= _size-pos;i++)
    {
        _str[_size + 1-i] = _str[_size-i];
    }
    _str[pos] = ch;
    _size++;
}

//任意位置插入一个字符串
void String::Insert(size_t pos, const char* str)
{
    if (pos<0 || pos>_size)
    {
        return;
    }
    size_t len = strlen(str);
    if (len + _size > _capacity)
    {
        ExpandCapacity(_size + len);
        _capacity += len;
    }
    for (size_t i = 0; i <= _size -pos; i++)
    {
        _str[_size +len- i] = _str[_size - i];
    }
    strncpy(_str + pos, str,len);
    _size += len;
}

//任意位置删除一个元素
void String::Erase(size_t pos)
{
    if (pos<0 || pos>_size)
    {
        return;
    }
    for (size_t i = 0; i <= _size - pos; i++)
    {
        _str[pos + i] = _str[pos + i + 1];
    }
    _size--;
}

//任意位置删除n个字符
void String:: Erase(size_t pos, size_t n)
{
    if (pos<0 || pos>_size || n > _size - pos)
    {
        return;
    }
    for (size_t i = 0; i <_size - n; i++)
    {
        _str[pos+i] = _str[pos + n + i];
    }
    _size -= n;
}

void String::display()
{
    cout << _str << endl;
}

测试函数：

#define _CRT_SECURE_NO_WARNINGS 1
#include"String.h"


void test1()
{
    String s1("hello");
    String s2(s1);
    String s3("hello");
    String s4;
    //s4=s3 + s1;
    cout << s2.Size() << endl;
    cout << s2[1] << endl;
    s3.display();
    s4.display();
    //cout << strcmp("hello", "hell") << endl;
    if (s1 < s3)
    {
        cout << "s1<s2" << endl;
    }
    s1.PushBack('a');
    s1.PushBack('b');
    s1.display();
    s1.Append("world");
    s1.display();
    s1.PopBack();
    s1.PopBackStr(5);
    s1.display();
    s1.PushFront('x');
    s1.display();
    s1.PopFront();
    s1.display();
    s1.Insert(1, 'a');
    s1.display();
    s1.Insert(6, "worlddddddddddddddddd");
    s1.display();
    s1.Erase(1);
    s1.display();
    s1.Erase(1, 5);
    s1.display();
}

int main()
{
    test1();
    system("pause");
    return 0;
}