作业:
在My_string类的基础上,完成运算符重载
算术运算符:+
赋值运算符:+=
下标运算符:[]
关系运算符:>、=、
插入提取运算符:>
要求:注意数据的保护(const)
头文件:
#ifndef HEADER_H
#define HEADER_H
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
class My_string
{
private:
char *data;
int size;
public:
//无参构造函数,默认值15
My_string();
//有参构造函数
My_string(const char *str);
//有参构造函数
My_string(int n,char ch);
//析构函数
~My_string();
//拷贝构造函数
My_string(const My_string &other);
//拷贝赋值函数
My_string & operator = (const My_string &other);
//输出字符串地址函数
char *c_str();
//字符串个数输出函数
bool size_t();
//empty函数
int empty();
//at函数
char & at(int num);
//遍历
void show();
//实现+运算符重载
const My_string operator+(const My_string &R);
//实现+=运算符重载
My_string & operator+=(const My_string &R);
//实现[]运算符重载
char &operator[](int index);
//实现>运算符重载
int operator>(const My_string &R)const;
//实现<运算符重载
int operator<(const My_string &R)const;
//实现==运算符重载
bool operator==(const My_string &R)const;
//实现!=运算符重载
bool operator!=(const My_string &R)const;
//实现>=运算符重载
bool operator>=(const My_string &R)const;
//实现<=运算符重载
bool operator<=(const My_string &R)const;
friend ostream &operator<<(ostream &L,const My_string &s);
friend istream &operator>>(istream &I,const My_string &s);
};
#endif // HEADER_H
源文件:
#include <iostream>
#include "header.h"
#include <string>
#include <cstring>
//无参构造函数,默认值15
My_string::My_string():size(15)
{
data = new char[size+1];
data[0] = '\0';
cout<<"无参构造"<<endl;
}
//有参构造函数
My_string::My_string(const char *str):size(strlen(str))
{
data = new char[size+1];
strcpy(data,str);
cout<<"有参构造"<<endl;
}
//有参构造函数
My_string::My_string(int n,char ch):size(n)
{
data = new char[size+1];
for(int i=0;i<size;i++)
{
data[i] = ch;
}
cout<<"有参构造"<<endl;
}
//析构函数
My_string::~My_string()
{
delete []data;
data = nullptr;
size = 0;
cout<<"析构函数"<<endl;
}
//拷贝构造函数
My_string::My_string(const My_string &other):size(other.size)
{
data = new char[size+1];
strcpy(data,other.data);
cout<<"拷贝构造函数"<<endl;
}
//拷贝赋值函数
My_string & My_string::operator = (const My_string &other)
{
if(this->size<other.size)
{
delete []data;
data = new char[other.size];
}
this->size = other.size;
strcpy(this->data,other.data);
cout<<"拷贝赋值"<<endl;
return *this;
}
//输出字符串地址函数
char *My_string::c_str()
{
return data;
}
//字符串个数输出函数
bool My_string::size_t()
{
return size;
}
//empty函数
int My_string::empty()
{
return 0 == size;
}
//at函数
char & My_string::at(int num)
{
if(num<0 || num>size-2)
{
cout<<"所给数据不合理"<<endl;
return data[-1];
}
return data[num];
}
//遍历
void My_string::show()
{
cout<<"data = "<<this->data<<endl;
cout<<"size = "<<this->size<<endl;
}
//实现+运算符重载
const My_string My_string::operator+(const My_string &R)
{
My_string temp;
temp.size = this->size+R.size;
temp.data = new char[temp.size+1];
strcpy(temp.data,this->data);
strcat(temp.data,R.data);
return temp;
}
//实现+=运算符重载
My_string & My_string::operator+=(const My_string &R)
{
My_string temp;
temp.size = (this->size+R.size);
temp.data = new char[temp.size+1];
strcpy(temp.data,this->data);
strcat(temp.data,R.data);
delete []this->data;
this->data = nullptr;
this->data = new char[temp.size+1];
strcpy(this->data,temp.data);
delete []temp.data;
temp.data = nullptr;
this->size = temp.size;
cout<<this->data<<endl;
cout<<size<<endl;
return *this;
}
//实现[]运算符重载
char &My_string::operator[](int index)
{
if(index<0 || index>=this->size)
{
cout<<"下标访问越界"<<endl;
}
//cout<<data[index]<<endl;
return this->data[index];
}
//实现>运算符重载
int My_string::operator>(const My_string &R)const
{
int i = 0;
int temp;
for(i=0;i<(this->size>=R.size?R.size:this->size);i++)
{
temp = this->data[i]-R.data[i];
if(temp)
{
}
if(this->data[i]>R.data[i])
{
return 1;
}
else if(this->data[i]<R.data[i])
{
return -1;
}
}
return this->data[i]-R.data[i];
}
//实现<运算符重载
int My_string::operator<(const My_string &R)const
{
int i = 0;
for(i=0;i<(this->size<=R.size?R.size:this->size);i++)
{
if(this->data[i]<R.data[i])
{
return 1;
}
else if(this->data[i]>R.data[i])
{
return -1;
}
}
return this->data[i]-R.data[i];
}
//实现==运算符重载
bool My_string::operator==(const My_string &R)const
{
if(this->size == R.size)
{
for(int i=0;i<size;i++)
{
if(this->data[i] != R.data[i])
{
return 0;
}
}
}
else
{
return 0;
}
return 1;
}
//实现!=运算符重载
bool My_string::operator!=(const My_string &R)const
{
if(this->size != R.size)
{
return 1;
}
else if(this->size == R.size)
{
for(int i=0;i<this->size;i++)
{
if(this->data[i] != R.data[i])
{
return 1;
}
}
}
return 0;
}
//实现>=运算符重载
bool My_string::operator>=(const My_string &R)const
{
int i=0;
if(this->size>=R.size)
{
for(i=0;i<this->size;i++)
{
if(this->data[i] > R.data[i])
{
return 1;
}
else if(this->data[i] < R.data[i])
{
return 0;
}
}
}
else
{
return 0;
}
return 1;
}
//实现<=运算符重载
bool My_string::operator<=(const My_string &R)const
{
int i=0;
if(this->size<=R.size)
{
for(i=0;i<R.size;i++)
{
if(this->data[i] < R.data[i])
{
return 1;
}
else if(this->data[i] > R.data[i])
{
return 0;
}
}
}
else
{
return 0;
}
return 0;
}
//实现>>运算符重载
ostream &operator<<(ostream &L,const My_string &s)
{
L<<s.data<<endl;
return L;
}
istream &operator>>(istream &I,const My_string &s)
{
I>>s.data;
return I;
}
主函数调用:
#include <iostream>
#include <string>
#include <cstring>
#include "header.h"
using namespace std;
int main()
{
My_string s1("abc");
My_string s2("bcd");
My_string s3("cde");
s3 = s1+s2;
My_string s4("ccc");
//s4+=s3;
if(s2>s1)
{
cout<<"s2大"<<endl;
}
return 0;
}