一、运算符重载
（一）定义
方法:定义重载运算符的函数
实质:函数的重载
格式:TYPE operator@(形参表){//重新定义运算符@的功能}
普通的复数相加写法:
#include <iostream>
using namespace std;
class Complex {
private:
double r;//实部
double i;//虚部
public:
Complex(double x= 0.0, double y = 0.0) {
r = x;
i = y;
}
Complex Add(const Complex &c);
void print();
};
Complex Complex::Add(const Complex &c) {
Complex t;
t.r = r + c.r;
t.i = i + c.i;
return t;
}
void Complex::print() {
cout<<"("<<r<<","<<i<<"i)"<<endl;
}
int main() {
Complex a(3.0, 4.0), b(10.5, 20.5), c, d, e;
c = a.Add(b);
c.print();
return 0;
}
//output:(13.5,24.5i)
运算符重载写法：
#include <iostream>
using namespace std;
class Complex {
public:
double r;//实部
double i;//虚部
void Print();
Complex(double x = 0.0, double y = 0.0) {//构造函数
r = x;
i = y;
}
};
Complex operator+(Complex &c1, Complex &c2) {
Complex t;
t.r = c1.r + c2.r;
t.i = c1.i + c2.i;
return t;
}
void Complex::Print() {
cout<<"("<<r<<","<<i<<"i)"<<endl;
}
int main() {
Complex a(3.0, 4.0), b(10.5, 20.5), c;
c = a + b;
cout<<"c:";
c.Print();
}
//输出：c:(13.5,24.5i)
（二）重载方法1——重载为类的成员函数
#include <iostream>
using namespace std;
class Complex {
private:
double r;//实部
double i;//虚部
public:
Complex operator+(const Complex &c);
Complex operator+(double d);
Complex(double x = 0.0, double y = 0.0) {//构造函数
r = x;
i = y;
}
void print();
};
Complex Complex::operator+(const Complex &c) {
Complex t;
t.r = r + c.r;
t.i = i + c.i;
return t;
}
Complex Complex::operator+(double d) {
Complex t;
t.r = r + d;
t.i = i;
return t;
}
void Complex::print() {
cout<<"("<<r<<","<<i<<"i)"<<endl;
}
int main() {
Complex a(3.0, 4.0), b(10.5, 20.5), c, d, e;
//运用重载的运算符+
d = a + b;
//e = a +10.5;//不能处理这句
d = a.operator + (b);
e = a.operator + (10.5);
d.print(); //(13.5,24.5i)
e.print(); //(13.5,4i)
return 0;
}
（三）重载方法2——重载为类的友元函数
定义：friend TYPE operator@(形参表);
#include <iostream>
using namespace std;
class Complex {
private:
double r;//实部
double i;//虚部
public:
friend Complex operator+(double d, const Complex &c);
Complex(double x = 0.0, double y = 0.0) {//构造函数
r = x;
i = y;
}
void print();
};
Complex operator+(double d, const Complex &c) {
Complex t;
t.r = d + c.r;
t.i = c.i;
return t;
}
void Complex::print() {
cout<<"("<<r<<","<<i<<"i)"<<endl;
}
int main() {
Complex a(3.0, 4.0), b(10.5, 20.5), c, d, e;
//d = a + b;//不能处理这句
e = 10.5 + a;//注意两个参数顺序不可反
//d = (b) + a.operator;//不能处理这句
//d = (10.5) + a.operator;//不能处理，operator+ 是一个重载的运算符函数，不需要像成员函数那样使用点操作符进行调用
e.print(); //(13.5,4i)
return 0;
}
（四）规则
- 不能定义新的运算符
- 下面的运算符不可重载:.、.*、::、?:、sizeof、
- 运算符的重载既不会改变原运算符的优先级和结合性，也不会改变使用运算符的语法和参数个数
- 重载运算符的函数不能包含有默认值的参数
- 重载的运算符必须与自定义类型的对象一起使用，要求其参数至少有一个是自定义类型的对象
- “=”和“&”不必用户重载。系统已为“=”提供默认的重载函数——实现对象间的浅拷贝，“&”获得对象
- 当重载为类的成员函数时，运算符重载函数的形参个数要比运算符操作数个数少一个;若重载为友元函数，则参数个数与操作数个数相同
- 只能通过成员函数重载的运算符：=、（）、[]、->
案例分析没看
二、数据类型转换
（一）分类
- 隐式（自动）类型转换 例
234+5.6 - 显式（强制）类型转换
类型名(数据)或(类型名)数据 - 自定义类型转换：①转换构造函数②运算符重载
（二）转换构造函数类型转换
具有带一个参数的调用形式的构造函数，把参数值（指定类型的数据）转换为类对象
#include <iostream>
using namespace std;
class Complex {
private:
double r;//实部
double i;//虚部
public:
Complex() {
r = i = 0.0;
}
Complex(double d) {
r = d;
i = 0.0;
}
// Complex(double d1, double d2 = 0.0) {//也可以
// r = d1;
// i = d2;
// }
friend Complex operator+(Complex c1, Complex c2);
};
Complex operator+(Complex c1, Complex c2) {
return Complex(c1.r+ c2.r, c1.i+ c2.i);
}
int main() {
Complex c1 = Complex(1.2);
c1 = Complex(1.2);
Complex c2 = 5.6;
c2 = 5.6;
Complex c3;
c3 = c1 + 5.6;
c3 = c1 + Complex(5.6);
c3 = c1 + (Complex)5.6;
return 0;
}
（三）类型转换函数类型转换(代码没看懂)
将一个类的对象转换成另一种类型的数据，只能是类的成员函数
形式:operator 类型名() { return 返回值}
class Complex {
operator double() {//将Complex类对象转换为double型数据
return r;
}
};
void main() {
Complex c4(1.2, 3.4);
double d;
d = c4 + 5.6;//double和Complex类型数据相加
d = 5.6 + c4;//不需要定义+运算符的重载函数
}
//“+”的左侧是double型数据，右侧是Complex类对象
//又无运算符“+”重载函数，不能直接相加
//系统发现有对double的重载函数，因此调用，返回double型数据，然后与2.5相加
**p32-p51没看**
三、标准库之string类
处理字符串的库：string.h或cstring或string类#include<string>
