自己封装String类

#include<iostream>
#include<assert.h>

using namespace std;

class MyString
{
public:
MyString();
MyString(const MyString&);
MyString(const char*);
MyString(const size_t, const char);
~MyString();

size_t Length();	// 字符串长度
bool empty();		// 字符串是否为空

const char *c_str();	// 返回c风格的字符串的指针

// 读写操作符
friend ostream &operator<<(ostream&, const MyString &);
friend istream &operator>>(istream&, MyString&);
// +
friend MyString operator+(const MyString&, const MyString&);
// 比较操作符
friend bool operator == (const MyString&, const MyString&);
friend bool operator != (const MyString&, const MyString&);
friend bool operator < (const MyString&, const MyString&);
friend bool operator <= (const MyString&, const MyString&);
friend bool operator > (const MyString&, const MyString&);
friend bool operator >= (const MyString&, const MyString&);
// 下标操作符
char &operator[](const size_t);
const char& operator[](const size_t) const;
//赋值操作符
MyString &operator = (const MyString&);
// '+='操作符
MyString &operator += (const MyString&);

// 成员函数
MyString substr(size_t, size_t);	//子串操作
MyString &append(const MyString&);	// 添加操作
MyString &insert(size_t, const MyString&);	//插入操作
MyString &assign(const MyString&, size_t, size_t);	// 替换操作
MyString &erase(size_t, size_t);	// 删除操作

private:
char *p_Str;
size_t strLength;
};

MyString::MyString():strLength(0), p_Str(NULL){}

MyString::MyString(const MyString &str)
{
strLength = str.strLength;
p_Str = new char[strLength + 1];
strcpy(p_Str, str.p_Str);
}

MyString::MyString(const char *str)
{
if(str == NULL)
{
return;
}
strLength = strlen(str);
p_Str = new char[strLength + 1];
strcpy(p_Str, str);
}

MyString::MyString(const size_t len, const char ch)
{
strLength = len;
p_Str = new char[strLength + 1];
*(p_Str + strLength) = '\0';
strset(p_Str, ch);	//功能：把字符串p_Str中的所有字符都设置成字符ch。说明：返回指向p_Str的指针。
}

MyString::~MyString()
{
delete[] p_Str;
}

size_t MyString::Length()
{
return strLength;
}

bool MyString::empty()
{
return strLength == 0 ? true : false;
}

const char *MyString::c_str()
{
return p_Str;
}

ostream &operator<<(ostream &out, const MyString &str)
{
if(str.p_Str != NULL)
out<<str.p_Str;
return out;
}

istream &operator>>(istream &in, MyString &str)
{
char temp[100];
if(in>>temp)
{
delete[] str.p_Str;
str.strLength = strlen(temp);
str.p_Str = new char[str.strLength + 1];
strcpy(str.p_Str, temp);
}
return in;
}

// 下标操作符
char &MyString::operator[](const size_t index)
{
assert(index >= 0 && index <= strLength);
return p_Str[index];
}

const char &MyString::operator[](const size_t index)const
{
assert(index >= 0 && index <= strLength);
return p_Str[index];
}

MyString operator+(const MyString &lhs, const MyString &rhs)
{
MyString ret;
ret.strLength = lhs.strLength + rhs.strLength;
ret.p_Str = new char[ret.strLength + 1];
strcpy(ret.p_Str, lhs.p_Str);
/*
原型声明：char *strcpy(char* dest, const char *src);
头文件：#include <string.h> 和 #include <stdio.h>
功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
*/
strcat(ret.p_Str, rhs.p_Str);
/*
原型
extern char *strcat(char *dest,char *src);
用法
#include <string.h>
在C++中，则存在于<cstring>头文件中。
功能
把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')。
说明
src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
*/
}

MyString &MyString::operator=(const MyString &str)
{
if(this != &str)
{
if(strLength < str.strLength)
{
delete[] p_Str;
p_Str = new char[str.strLength + 1];
}
strLength = str.strLength;
strcpy(p_Str, str.p_Str);
}
return *this;
}

MyString &MyString::operator+=(const MyString &str)
{
if(this == &str)
{
MyString copy(str);
return *this += copy;
}
strLength += str.strLength;
char *p_Old = p_Str;
p_Str = new char[strLength + 1];
strcpy(p_Str, p_Old);
delete[] p_Old;
strcat(p_Str, str.p_Str);
return *this;
}

bool operator==(const MyString &lhs, const MyString &rhs)
{
return strcmp(lhs.p_Str, rhs.p_Str) == 0;
/*
当s1<s2时，返回为负数；
当s1=s2时，返回值= 0；
当s1>s2时，返回正数。
*/
//
}

bool operator!=(const MyString &lhs, const MyString &rhs)
{
return strcmp(lhs.p_Str, rhs.p_Str);
}

bool operator<(const MyString &lhs, const MyString &rhs)
{
return strcmp(lhs.p_Str, rhs.p_Str) < 0;
}

bool operator<=(const MyString &lhs, const MyString &rhs)
{
return strcmp(lhs.p_Str, rhs.p_Str) > 0;
}

bool operator>(const MyString &lhs, const MyString &rhs)
{
return strcmp(lhs.p_Str, rhs.p_Str) > 0;
}

bool operator>=(const MyString &lhs, const MyString &rhs)
{
return strcmp(lhs.p_Str, rhs.p_Str) >= 0;
}

//子串操作
//返回一个MyString类型的字符串，它包含源字符串中从下标pos开始的n个字符
MyString MyString::substr(size_t pos, size_t n)
{
assert(pos + n <= strLength);
MyString ret;
ret.strLength = n;
ret.p_Str = new char[ret.strLength + 1];
for(size_t i = 0; i != n; ++i)
{
ret[i] = (*this)[pos + i];
}
ret
= '\0';
return ret;
}

//添加操作
//将一个字符串的副本添加到源字符串的末尾，同“+=”操作符类似
MyString &MyString::append(const MyString &str)
{
*this += str;
return *this;
}

//插入操作
//在下标为pos的元素之前插入MyString对象str的副本
MyString &MyString::insert(size_t pos, const MyString &str)
{
assert(pos < strLength);
char *p_Old = p_Str;
strLength += str.strLength;
p_Str = new char[strLength + 1];
for(size_t i = 0; i != pos; i++)
{
*(p_Str + i) = *(p_Old + i);
}
for(size_t i=pos;i!=str.strLength+pos;++i)
*(p_Str+i) = *(str.p_Str+i-pos);
for(size_t i=str.strLength+pos;i!=strLength;++i)
*(p_Str+i) = *(p_Old+i-str.strLength);
*(p_Str+strLength)='\0';
delete[] p_Old;
return *this;
}

//替换操作
//用s2中从下标pos开始的len个字符副本替换源字符串
MyString& MyString::assign(const MyString& s2,size_t pos,size_t len)
{
if(strLength<len)
{
strLength = len;
delete[] p_Str;
p_Str = new char[strLength+1];
}
for(size_t i=0;i!=len;++i)
*(p_Str+i)=s2[pos+i];
*(p_Str+strLength)='\0';
return *this;
}

//删除操作
//删除从下标pos开始的len个字符
MyString& MyString::erase(size_t pos,size_t len)
{
assert(pos+len<=strLength);
size_t index = pos + len;
while(*(p_Str+index)!='\0')
{
*(p_Str+index-len)=*(p_Str+index);
++index;
}
*(p_Str+index-len)='\0';
return *this;
}

int main()
{

//
system("pause");
return 0;
}

#include<iostream>
using namespace std;

class MyString
{
public:
MyString();
MyString(const char *str = 0);
MyString(const MyString &other); //拷贝构造函数
~MyString();

MyString &operator=(const MyString &other);

private:
char *m_Data;
};

//默认构造函数
MyString::MyString()
{
m_Data = new char[1];
*m_Data = 0;
}

//自定义构造函数
MyString::MyString(const char *str)
{
if(str == 0)
{
m_Data = new char[1];
*m_Data = 0;
}
else
{
m_Data = new char[strlen(str)];
strcpy(m_Data, str);
}
}

//拷贝构造函数
MyString::MyString(const MyString &other)
{
m_Data = new char[strlen(other.m_Data) + 1];
strcpy(m_Data, other.m_Data);
}

//析构函数
MyString::~MyString()
{
delete[] m_Data;
}

//重载赋值运算符函数
MyString::&MyString::operator=(const MyString &other)
{
//自检查，防止自己赋值给自己
if(this == &other)return *this;
//删除原来的内存资源
delete[] m_Data;
m_Data = new char[strlen(other.m_Data) + 1];
strcpy(m_Data, other.m_Data);
return *this;
}