1.完善my_string类,将能够重载的运算符,全部进行重载;
---mystring.h---头文件
#ifndef MYSTRING_H
#define MYSTRING_H
#include <iostream>
#include <cstring>
using namespace std;
class myString
{
private:
char *str; //记录C风格字符串
int size; //字符串实际长度
public:
//无参构造
myString();
//有参构造
myString(const char *s);
//拷贝构造
myString(const myString& other);
//拷贝赋值,先释放空间
myString &operator = (const myString &other);
//析构函数
~myString();
//判空函数
bool Empty();
//size函数
int Size();
//c_str函数
char* C_str();
//at函数
char &my_at(int pos);
void show(); //输出size str
//加号运算符重载,size,str
const myString operator + (const myString &R)const
{
myString temp;//(无参构造)
temp.size = this->size + R.size;
temp.str = new char[(temp.size)+1];
strcpy(temp.str,str);
delete []str;
return strcat(temp.str,R.str);
}
//加等于运算符重载
myString &operator += (const myString &R)
{
size += R.size;
char *newstr = new char[size + 1];
strcpy(newstr,str);
strcat(newstr,R.str);
delete [] str;
str = newstr;
return *this;
}
//关系运算符重载==
bool operator == (const myString &R)const
{
return strcmp(this->str,R.str) == 0;
}
//单目运算符重载 &
const myString *operator &()const
{
return this;
}
//前置自增(++O)运算符重载,size+1,str+1(指针移动一字符)
myString &operator ++()
{
++this->size;
++this->str;
return *this;
}
//后置自增(O++)运算符重载,存储变化之前的数据
myString operator ++(int)
{
myString temp;
temp.size = size++;
temp.str = new char[(temp.size)+1];
// temp.str = str++;
strcpy(temp.str,str);
return temp;
}
//中括号[]运算符重载
char &operator[] (const int index)
{
if (index >= 0 && index < size)
{
return str[index];
}else
{
// 处理越界情况
return str[0];
}
}
//重载小括弧运算符
void operator()(string msg)
{
cout<<"msg = "<<msg<<endl;
}
};
#endif // MYSTRING_H
---mystring.cpp---函数实现
#include "mystring.h"
myString::myString():size(10) //无参构造
{
str = new char[size];
strcpy(str,"");
}
myString::myString(const char *s) //有参构造
{
size = strlen(s);
str = new char[size+1];
strcpy(str,s);
}
myString::myString(const myString &other) //拷贝构造
{
size = other.size;
str = new char[size+1];
strcpy(str,other.str);
}
myString &myString::operator = (const myString &other) //拷贝赋值
{
if(this != &other)
{
delete []str;
size = other.size;
str = new char[size+1];
strcpy(str,other.str);
}
return *this;
}
myString::~myString() //析构函数
{
delete []str;
}
bool myString::Empty() //判空函数
{
return size == 0;
}
int myString::Size() //size函数
{
return strlen(str);
}
char* myString::C_str() //c_str函数
{
return str;
}
char & myString::my_at(int pos) //at函数
{
if(pos<0 || pos>size-1)
{
cout<<"越界访问"<<endl;
return str[0];
}
return str[pos];
}
void myString::show()
{
cout<<"size= "<<size<<" str= "<<str<<endl;
}
---main.cpp---主函数
#include "mystring.h"
int main()
{
myString s1("hello world"); //有参构造
s1.show();
cout<<endl;
myString s2(s1); 拷贝构造
s2.show();
cout<<endl;
myString s4; //拷贝赋值
s4 = s1;
s4.show();
if(s1.Empty()) // 判空
cout<<"空串"<<endl;
cout<<"非空串"<<endl;
cout<<"s1.Size= "<<s1.Size()<<endl; //size函数,得到实际大小
cout<<endl;
cout<<"s2.C_str= "<<s1.C_str()<<endl; //c_str函数,得到起始地址
cout<<endl;
cout<<"s1.my_at(0)= "<<s1.my_at(0); //at函数,访问字符
cout<<" s1.my_at(1)= "<<s1.my_at(1)<<endl;
cout<<endl;
myString s3; //加号运算符重载
s3 = s1 + s2;
s3.show();
cout<<endl;
myString s5("nihao"); //加等于运算符重载
myString s6("hello");
s5 += s6;
s5.show();
cout<<endl;
if(s1==s2) //关系运算符重载==
cout<<"相等"<<endl;
else
cout<<"不相等"<<endl;
cout<<endl;
cout<<"&s1= "<<&s1<<endl; //单目运算符重载 &
cout<<endl;
++s6; //前置自增(++O)运算符重载,size+1,str+1(指针移动一字符)
s6.show();
myString s7("zhang");
s7++; //后置自增(O++)运算符重载,存储变化之前的数据
s7.show();
cout<<endl;
cout<<"s7[1]= "<<s7[1]<<" s7[3]= "<<s7[3]<<endl; //中括号[]运算符重载
cout<<endl;
s1("long time"); //重载小括弧运算符
return 0;
}
结果测试---
2. 将继承过程中特殊成员函数相关代码;
#include <iostream>
using namespace std;
class Father //父类
{
protected:
string name;
public:
Father() {cout<<"fa无参构造"<<endl;}
Father(string n):name(n) {cout<<"fa有参构造"<<endl;}
Father(const Father &other):name(other.name){cout<<"fa拷贝构造函数"<<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(const Son &other):Father(other),toy(other.toy) //传other
{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;
}
~Son() {cout<<"son::析构函数"<<endl;}
};
int main()
{
Son s1; //无参构造
cout<<endl;
Son s2("关羽","摩托车"); //有参构造
cout<<endl;
Son s3(s2); //拷贝构造
s3.show();
cout<<endl;
Son s4;
s4 = s2; //拷贝赋值
s4.show();
cout<<endl;
return 0;
}