封装string类

//Mystring.h

#include <iostream>
using namespace std;


class MyString
{
public:
MyString();    //无参构造
MyString(const char *p); //有参构造  C方式
MyString(const MyString &obj);   //有参构造C++方式
~MyString();   //析构函数




int size();   //获得字符串长度
const char * c_str()const;   //把string类对象c_str 转换为C风格字符串


char *begin() const;     //返回该对象第一个地址
char *end()const;     //返回该对象最后一个地址


bool in(const char *s)const;      //判断某个对象是否在另一个对象中,可以是字符串也可以是另一个String对象
bool in(const MyString &s)const;  
bool in(const char s)const;           


char *get(int start, int end)const;    //从对象中截取一段字符出来,从strrt开始到end结束
void del(const char s);   //删除对象中的字符, 将对象中与之匹配的字符全部删除




//重载+
MyString operator+(const char *s)const;    //C风格
MyString operator+(const MyString &s)const; //C++风格
friend MyString operator+(const char *s, const MyString &st);


MyString& operator+=(MyString &str);
MyString& operator+=(const char *str);
//重载=  拷贝构造
void operator=(const char *s);   //C风格
void operator=(const MyString &s);   //C++风格


//重载<
bool operator<(const char *s)const;   //C风格
bool operator<(const MyString &s)const;      //C++风格
friend bool operator<(const char *s, const MyString &st);
//重载 >
bool operator>(const char *s)const;    //C风格
bool operator>(const MyString &s)const;   //C++风格
friend bool operator>(const char *s, MyString &st);




//重载>=
bool operator>=(const char *s)const;   //C风格
bool operator>=(const MyString &s)const;   //C++风格
friend bool operator>=(const char *s, MyString &st);
//重载<=
bool operator<=(const char *s)const; ///C风格
bool operator<=(const MyString &s)const;   //C++风格
friend bool operator<=(const char *s, MyString &st);






//重载==
bool operator==(const char *s)const;
bool operator==(const MyString &s)const;
friend bool operator==(const char *s, MyString &st);


//重载>>
friend ostream &operator<<(ostream &os, const MyString &s);
friend void operator>>(const char *s,  MyString &st);










private:
char *str;
int len;






};

//Mystring.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "Mystring.h"




bool strcmp_m(char *str, const char *s, int size)
{
char *m;
m = str + size;
for (int i = 0; s[i]; ++i)
{
if (*m == s[i])
{
m++;
}
else
{
return false;
}
}
return true;
}
MyString::MyString()    //无参构造
{
this->str = new char[1];
this->str = NULL;
this->len = 0;
}




MyString::MyString(const char *s) //有参构造  C方式
{
this->len = strlen(s);
this->str = new char[len + 1];
strcpy(str, s);


}




MyString::MyString(const MyString &obj)   //有参构造C++方式
{
this->len = obj.len;
this->str = new char[this->len + 1];


strcpy(this->str, obj.str);


}


MyString::~MyString()   //析构函数
{
if (this->str != NULL)
{
delete[]this->str;
this->str = NULL;


}
}


int MyString::size() //字符串长度
{
return this->len;



}
const char * MyString::c_str()const   //把string类对象c_str 转换为C风格字符串普通函数
{
return this->str;


}


char * MyString::begin() const     //返回该对象第一个地址
{
if (str == NULL)
{
return NULL;
}


return str;




}
char *MyString::end()const     //返回该对象最后一个地址
{
if (str == NULL)
{
return NULL;
}


else
{
char *p;
p = new char;
p = str;
for (int i = 0; str[i]; ++i)
{
p++;
}
return p;
}




}


bool MyString::in(const char *s)const      //判断某个对象是否在另一个对象中,可以是字符串也可以是另一个String对象
{




int n;
n = strlen(s);
for (int i = 0; i < len && (len - i) >= n; ++i)
{
if (s[0] == str[i])
{
if (strcmp_m(str, s, i))
{
return true;
}
}
}


return false;


}
bool MyString::in(const MyString &s)const
{
int n = s.len;
for (int i = 0; i < len && (len - i) <= n; ++i)
{
if (s.str[0] == str[i])
{
if (strcmp_m(str, s.str, i))
return true;
}
}


return false; 
}
bool MyString::in(const char s)const
{


for (int i = 0; str[i]; ++i)
{
if (s == str[i])
{
return true;
}
}


return false;


}


char *MyString::get(int start, int end)const   //从对象中截取一段字符出来,从start开始到end结束
{
char *p;
if (end > len)
{
return NULL;
}


p = new char[end - start + 1];
int j = 0;
for (int i = 0; i < start - 1; ++i)
{
for (; i < end - 1; ++i)
{
p[j++] = str[i];
}
}
p[j] = '\0';
return p;
}


void MyString::del(const char s)   //删除对象中的字符, 将对象中与之匹配的字符全部删除
{


char *temp;
int j = 0;
temp = new char[len + 1];
for (int i = 0; str[i]; ++i)
{
if (str[i] != s)
{
temp[j++] = str[i];
}
}
len = j;
temp[j] = '\0';
delete[]str;
str = new char[len + 1];
strcpy(str, temp);
delete[]temp;






}




//重载+
MyString MyString::operator+(const char *s)const    //C风格
{
MyString st;
st.len = len;
st.len += strlen(s);
st.str = new char[st.len + 1];
strcpy(st.str, str);
return st;






}




MyString MyString::operator+(const MyString &s)const //C++风格
{
MyString st;
st.len = len;
st.len += s.len;
st.str = new char[st.len + 1];
strcpy(st.str, str);
strcat(st.str, s.str);
return st;






}




MyString operator+(const char *s, const MyString &st)
{
MyString ss;
ss.len = strlen(s);
ss.len += st.len;
ss.str = new char[ss.len + 1];
strcpy(ss.str, s);
strcat(ss.str, st.str);
return ss;
}


//重载=  拷贝构造
void MyString::operator=(const char *s)   //C风格
{


this->len = strlen(s);
str = new char[len + 1];
strcpy(str, s);


}
void MyString::operator=(const MyString &s)  //C++风格
{
this->len = s.len;
str = new char[len + 1];
strcpy(str, s.str);
}


//重载<
bool MyString::operator<(const char *s)const   //C风格
{
if (strcmp(str, s) < 0)
{
return true;
}
else
{
return false;
}


}




bool MyString::operator<(const MyString &s)const      //C++风格
{
if (strcmp(str, s.str) < 0)
{
return true;
}


else
{
return false;
}
}
bool operator<(const char *s, const MyString &st)
{
if (strcmp(s, st.str)<0)
{
return true;
}
else
{
return false;
}




}
//重载 >
bool MyString::operator>(const char *s)const   //C风格
{


if (strcmp(str, s) > 0)
{
return true;
}


return false;




}
bool MyString::operator>(const MyString &s)const   //C++风格
{
if (strcmp(str, s.str) > 0)
{
return true;
}


return false;


}
bool operator>(const char *s, MyString &st)
{


if (strcmp(s, st.str) > 0)
{
return true;
}


else
{
false;
}
}




//重载>=
bool MyString:: operator>=(const char *s)const   //C风格
{
if (strcmp(str, s) >= 0)
{
return true;
}


return false;


}
bool MyString::operator>=(const MyString &s)const   //C++风格
{
if (strcmp(str, s.str) >= 0)
{
return true;
}


return false;


}
bool operator>=(const char *s, MyString &st)
{
if (strcmp(s, st.str) >= 0)
{
return true;
}


else
{
return false;
}


}
//重载<=
bool MyString::operator<=(const char *s)const ///C风格
{
if (strcmp(str,s)<=0)
{
return true;
}


return false;


}
bool MyString:: operator<=(const MyString &s)const   //C++风格
{
if (strcmp(str, s.str) <= 0)
{
return true;
}


return false;


}
bool operator<=(const char *s, MyString &st)
{
if (strcmp(s,st.str) <= 0)
{
return true;
}
else
{
return false;
}


}


//重载==
bool MyString::operator==(const char *s)const
{


if (strcmp(str, s) == 0)
{
return true;
}


else
{
false;
}






}
bool MyString::operator==(const MyString &s)const
{


if (strcmp(str, s.str) == 0)
{
return true;
}


else
{
false;
}


}
bool operator==(const char *s, MyString &st)
{


if (strcmp(s, st.str) == 0)
{
return true;
}


else
{
false;
}


}


//重载<<
ostream &operator<<(ostream &os, const MyString &s)
{
os << s.str;
return os;
}
void operator>>(const char *s, MyString &st)
{
if (st.str!= NULL)  //判断str是否为空
{
delete[]st.str;       
}
st.str = new char[strlen(s) + 1];
for (int i = 0; i < strlen(s); ++i)
{
st.str[i] = '\0';
}


strcpy(st.str, s);

}




MyString& MyString::operator+=(MyString &st)
{
if (st.len == 0)
{
return *this;
}


//计算两个字符串总长
this->len = this->len + st.len;


//申请两个字符串长度的空间
char *pTemp = new char[this->len + 1];




  //初始化数组
for (int i = 0; i < this->len + 1; ++i)
{


pTemp[i] = '\0';
}


//拷贝两个字符串到新空间中
char *p = pTemp; 
strcat(p, this->str);
strcat(p, st.str);


//释放空间
if (this->str != NULL)
{
delete[]this->str;
this->str = NULL;
}


//更新str指针
this->str = pTemp;
return *this;
}


MyString& MyString::operator+=(const char *s)
{
//判断追加字符串是否为空
if (s == NULL || strlen(s) == 0)
{
return *this;
}
this->len = this->len + strlen(s);


//申请两个字符串长度的空间
char *pTemp = new char[this->len + 1];


//初始化数组
for (int i = 0; i < this->len + 1; ++i)
{


pTemp[i] = '\0';
}


//拷贝两个字符串到新空间
strcat(pTemp, this->str);
strcat(pTemp, s);


if (this->str != NULL)
{
delete[]this->str;
this->str = NULL;
}


//更新指针
this->str = pTemp;
return *this;
}

//main.cpp

#include <iostream>
#include "Mystring.h"
using namespace std;




void main()
{
MyString str1("bbbb");
MyString str2("aaaa");
str1 += str2;
cout << str1 << endl;




system("pause");

}