字符串的操作函数

#ifndef _My_String_
#define _My_String_


#include <iostream>


class MyString
{
private:
int size;
char *data;


public:
void print()
{
std::cout<<data<<std::endl;
}


int length()
{
return size;
}


public:
MyString();//默认构造函数
MyString(const char *source);//普通构造函数
MyString(const MyString &s);普通构造函数
MyString(int n, char c);//普通构造函数
MyString &operator=(char *s);//重载=操作，实现字符串赋值
MyString &operator=(const MyString &s);//重载=操作，实现对象赋值
~MyString();//析构函数
char &operator[](int i);//重载[]，实现数组运算
const char &operator[](int i)const;//const
MyString &operator+=(const MyString &s);//实现+=操作符，实现与对象相加
MyString &operator+=(const char *s);//实现+=操作符，实现与字符串相加
friend bool operator<(const MyString &left, const MyString &right); //重载<,比较两个对象的大小
friend bool operator>(const MyString &left, const MyString &right);

friend std::ostream& operator<<(std::ostream &out, MyString &s);//重载<<操作符，实现输出流
friend std::istream &operator>>(std::istream &in, MyString &s);重载>>操作符，实现输入流




};

#endif

#define _CRT_SECURE_NO_WARNINGS//如果在vs上面运行就加上，在Linux上面就去掉
#include <string.h>
#include "MyString.h"
#include <iostream>
using namespace std;


//默认的普通构造函数,只有一个含有‘\0’的空字符
MyString::MyString()
{
data = new char[1];
*data = '\0';
size = 0;
}


//当source不为空时，给对象赋值为source字符串
MyString::MyString(const char *source)
{
if (source == NULL)
{
data = new char[1];
*data = '\0';
size = 0;
}
else
{
size = strlen(source);
data = new char[size+1];
strcpy(data, source);
}
}


//复制构造函数，该对象的内容为s对象的相同
MyString::MyString(const MyString &s)
{
data = new char[s.size + 1];
strcpy(data, s.data);
size = s.size;
}


//默认的普通构造函数,含有n个相同字符的字符串
MyString::MyString(int n, char c)
{
data = new char[n+1];
size = n;
char *temp = data;
while (n--)
 *temp++ = c;
*temp = '\0';
}


//重载=操作符，s为目标字符串，该对象的内容与s相同
MyString& MyString::operator=(char *s)
{
if (data != NULL)
 delete [] data;

size = strlen(s);
data = new char[size+1];
strcpy(data, s);


return *this;
}


//重载=操作符，目标为MyString对象，实现拷贝s对象的内容
MyString& MyString::operator=(const MyString &s)
{
if (this == &s)
 return *this;


if (data != NULL)
 delete [] data;


size = strlen(s.data);
data = new char[size+1];
strcpy(data, s.data);


return *this;
}


//析构函数，释放内存
MyString::~MyString()
{
if (data != NULL)
{
delete [] data;
data = NULL;
size = 0;
}
}


//重载[]操作符，返回下表为i的char
char &MyString::operator[](int i)
{
return data[i];
}


//const指针
const char &MyString::operator[](int i)const
{
return data[i];
}


//重载+=操作符，实现对象相加
MyString& MyString::operator+=(const MyString &s)
{
int len = size + s.size +1;
char *temp = data;
data = new char[len];
size = len-1;
strcpy(data, temp);
strcat(data, s.data);
delete [] temp;


return *this;
}


//重载+=操作符，实现对象与s的内容相加
MyString& MyString::operator+=(const char *s)
{
if (s == NULL)
 return *this;
int len = size + strlen(s) + 1;
char *temp = data;
data = new char[len];
size = len-1;
strcpy(data, temp);
strcat(data, s);
delete [] temp;


return *this;
}


//重载<<运算符，实现输出流，注意，这里ostream不能是const
ostream &operator<<(ostream &out, MyString &s)
{
for (int i = 0; i < s.length(); i++)
 out<<s[i];


return out;
}


istream &operator>>(istream &in, MyString &s)
{
char p[1024];
in.getline(p, 1024);
s = p;


return in;
}


//重载<
bool operator<(const MyString &left, const MyString &right)
{
int i = 0;
while (left[i] == right[i] && left[i] != 0 && right[i] != 0)
 i++;


return left[i] - right[i] < 0 ? true : false;
}


//重载>
bool operator>(const MyString &left, const MyString &right)
{
int i = 0;
while (left[i] == right[i] && left [i] != 0 && right[i] != 0)
 i++;


return left[i] - right[i] > 0 ? true : false;
}



//主函数

#define _CRT_SECURE_NO_WARNINGS//如果在vs上面运行就加上，在Linux上面就去掉
#include <iostream>
#include "MyString.h"
using namespace std;


int main(int argc, char *argv[])
{
MyString s("hello");
MyString ss(s);
MyString sss(10, 'c');



s = sss;//重载=号操作符

s.print();
ss.print();
sss.print();


char c = s[3];//操作[]操作符
cout<<c<<endl;


s += sss;//操作+=操作符


s.print();


s += "AAAAAAAAAAAAAA";操作+=操作符
s.print();
 
cout<<s<<endl;
 
cout << "s < ss ? " << (s < ss)<<endl;
 
cout <<"s > sss ? " <<(s > sss)<<endl;




cout<<"input you input string"<<endl;


 
cin >> s;//重载>>运算符 注意---> >>和<<运算符只能是友元函数


cout<<s<<endl;//重载<<运算符  注意---> >>和<<运算符只能是友元函数

cout<<"hello world"<<endl;


system("pause");


return 0;
}