1. 仿照string类,实现Mystring类
运算符重载:[] () cin cout
#include <iostream>
#include <cstring>
using namespace std;
class myString
{
private:
char *str; //记录c风格的字符串
int size; //记录字符串的实际长度
public:
//无参构造函数
myString():size(10)
{
str = new char[size]; //构造出一个长度为10的字符串
strcpy(str,""); //赋值为空串
}
//有参构造函数
myString(const char *s) //string s("hello world")
{
size = strlen(s);
str = new char[size+1];
strcpy(str, s);
}
//拷贝构造函数
myString(const myString& other) // 深拷贝
{
size = strlen(other.str);
str = new char(size+1);
strcpy(str, other.str);
cout<<"myString::拷贝构造"<<endl;
}
//析构函数
~myString()
{
delete []str;
str = nullptr;
}
//拷贝赋值函数
myString& operator=(const myString &other)
{
if(this != &other) //防止自己给自己赋值
{
this->size = strlen(other.str);
this->str = new char(size+1);//给指针成员单独开辟内存空间
strcpy(this->str, other.str);
}
return *this; //返回自身的引用
}
//判空函数
bool empty()
{
return !strlen(this->str);
}
//size函数
unsigned int stringsize()
{
return strlen(this->str);
}
//c_str函数
const char *c_str()
{
cout<<this->str<<endl;
return this->str;
}
//at函数
char &at(int pos)
{
if(pos<0 || pos>this->size)
{
cout<<"输入越界"<<endl;
}
return str[pos];
}
//成员函数版实现 [] 运算符重载
char operator[](const int index)
{
if(index<0 || index>this->size)
{
cout<<"输入越界"<<endl;
}
return this->str[index];
}
//成员函数版实现+运算符重载
const myString operator+(const myString &R)const
{
myString temp; // 调用无参构造,长度只有10
temp.size=this->size+R.size;
temp.str=new char[temp.size+1];
strcpy(temp.str,this->str);
strcat(temp.str,R.str);
return temp;
}
//成员函数版实现+=运算符重载
myString& operator+=(const myString &R)
{
strcat(this->str,R.str);
return *this;
}
//关系运算符重载(>)aaaaaaaaaa
bool operator>(const myString &R)const
{
return strcmp(this->str,R.str)>0;
}
friend ostream& operator<<(ostream& out, myString& other);
friend istream& operator>>(istream& cin, myString& other);
};
//实现一个<<运算符重载;
ostream& operator<<(ostream& out, myString& other)
{
out << other.str;
return out;
}
//实现一个>>运算符重载;
istream& operator>>(istream& in, myString& other)
{
in >> other.str;
return cin;
}
int main()
{
myString c1("hello");
c1.c_str();
myString c2("world world world world");
c2.c_str();
myString c3;
c3=c1+c2;
c3.c_str();
c1+=c2;
c1.c_str();
if(c1>c2) // >
{
cout<<"yes"<<endl;
}
else
{
cout<<"no"<<endl;
}
cout<<c1.at(1)<<endl; //at
cout<<c1[1]<<endl; //[]
myString c4;
cin>>c4; //cin
cout<<c4<<endl; //cout
return 0;
}
2.继承
#include <iostream>
using namespace std;
class Father
{
protected:
string name;
public:
Father() {cout<<"Father::无参构造"<<endl;} //父类无参构造
Father(string n):name(n) {cout<<"Father::有参构造"<<endl;} //父类有参构造
Father(const Father &other):name(other.name){cout<<"Father::拷贝构造"<<endl;}
Father& operator=(const Father& other)
{
if(this!=&other)
{
this->name = other.name;
}
cout<<"Father::拷贝赋值"<<endl;
return *this;
}
~Father() {cout<<"Father::析构函数"<<endl;} //父类析构函数
};
class Son:public Father
{
private:
string toy; //玩具
public:
Son() {cout<<"Son::无参构造"<<endl;} //子类无参构造
Son(string n,string t):Father(n),toy(t) {cout<<"Son::有参构造"<<endl;} //子类有参构造
~Son() {cout<<"Son::析构函数"<<endl;} //子类析构函数
Son(const Son &other):Father(other) ,toy(other.toy) {cout<<"Son::拷贝构造"<<endl;} //子类的拷贝构造函数(父类+子类)
Son& operator=(const Son& other)
{
if(this != &other)
{
//显性调用父类的拷贝赋值函数
Father::operator=(other); //完成对子类从父类继承下来成员的赋值工作
this->toy = other.toy; //自己拓展的成员,由自己的拷贝赋值函数完成
}
cout<<"Son::拷贝赋值"<<endl;
return *this;
}
void show()
{
cout<<"name = "<<name<<" toy = "<<toy<<endl;
}
};
int main()
{
Son s1; //调用无参构造
Son s2("zhangsan","car"); //调用有参构造
Son s3(s2); //调用拷贝构造
s1=s3; //调用拷贝赋值函数
s1.show();
return 0;
}
3.思维导图