9.1运算符重载

运算符重载使得用户自定义的数据以一种更简洁的方式工作。

重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：

不改变运算符的优先级。

不改变运算符的结合性。

不改变运算符所需要的操作数。

不能创建新的运算符。

运算符重载的语法形式

运算符重载是一种特殊的成员函数或友元函数。

成员函数的语法形式为：

类型 类名::operator op(参数表)

{

//相对于该类定义的操作

}

//友元函数可以处理不同类型

//类运算符可以实现的，友元函数大部分都可以实现

//友元函数更强大

//=、()、[]、->这个4个运算符只能用类运算符来重载

复数重载运算符

重载<<

重载>>

重载前缀++

重载前缀--

重载()

#include <iostream>

//友元函数可以处理不同类型
//类运算符可以实现的，友元函数大部分都可以实现
//友元函数更强大
//=、()、[]、->这个4个运算符只能用类运算符来重载

class mycomplex
{
public:
    int x;
    int y;//xy坐标
    mycomplex()//构造函数
    {
        this->x = 0;
        this->y = 0;
    }
    mycomplex(int x, int y)//构造函数
    {
        this->x = x;
        this->y = y;
    }
    void operator ++();//重载前缀++
    void operator --();//重载前缀--
    int operator ()(int num);//重载()
    mycomplex operator +(mycomplex adddata);//重载+

    //ostream是标准输出流
    friend std::ostream &operator<<(std::ostream &, mycomplex &);//声明友元函数，重载<<
    //istream是标准输入流
    friend std::istream &operator>>(std::istream &, mycomplex &);//声明友元函数，重载>>
    friend mycomplex operator+(mycomplex adddata1, mycomplex adddata2);//重载+
};

void mycomplex::operator ++()//重载前缀++
{
    this->x++;
    this->y++;
}

void mycomplex::operator --()//重载前缀--
{
    this->x--;
    this->y--;
}

int mycomplex::operator ()(int num)//重载()
{
    std::cout << num << std::endl;
    return num + num;
}

mycomplex mycomplex::operator +(mycomplex adddata)
{
    mycomplex temp;
    temp.x = this->x + adddata.x;
    temp.y = this->y + adddata.y;
    return temp;
}

std::ostream &operator<<(std::ostream & out, mycomplex & Complex)//定义友元函数，重载<<
{
    std::cout << Complex.x << "+" << Complex.y << "i" << std::endl;
    return out;
}

std::istream &operator>>(std::istream & in, mycomplex & Complex)//定义友元函数，重载>>
{
    std::cout << "请输入xy" << std::endl;
    in >> Complex.x;
    in >> Complex.y;
    return in;
}

mycomplex operator+(mycomplex adddata1, mycomplex adddata2)//重载+
{
    mycomplex temp;
    temp.x = adddata1.x + adddata2.x;
    temp.y = adddata1.y + adddata2.y;
    return temp;
}

void main()
{
    mycomplex my1(7, 8), my2(9, 10);

    std::cout << my1;//重载<<
    std::cout << my2;//重载<<

    mycomplex my3;

    std::cin >> my3;//重载>>

    ++my3;//重载前缀++
    --my3;//重载前缀--
    
    std::cout << my3;//重载<<

    std::cout << my3(1) << std::endl;//重载()

    std::cout << my1 + my2 << std::endl;

    system("pause");
}

重载<<

重载>>

输出<<输入>>和外部有关系，因此使用友元函数重载运算符

重载前缀++

重载前缀--

重载()

自增++自减--括号()和外部没有关系，因此使用类运算符重载

用成员或友元函数重载运算符

运算符函数可以重载为成员函数或友元函数。

关键区别在于成员函数具有this指针，友元函数没有this指针。

不管是成员函数函数还是友元函数重载，运算符的使用方法相同。

但传递参数的方式不同，实现代码不同，应用场合也不同。

重载赋值运算符

赋值运算符重载用于对象数据的复制。

operator=必须重载为成员函数

重载函数原型为：

类型 & 类名::operator=(const 类名&);

6.4类的类型转换

6.4.1构造函数进行类类型转换

6.4.2类型转换函数

6.4.1构造函数进行类类型转换

数据类型转换在程序编译时或在程序运行实现：

基本类型<-->基本类型

基本类型<-->类类型

类类型<-->类类型

类对象的类型转换可由两种方式说明：

构造函数 转换函数

称为用户定义的类型转换或类类型转换，有隐式调用和现式调用方式。

隐式调用和现式调用

1 void main()
2 {
3     int num1 = (int)10.8;//显式转换
4     int num2 = 10.8;//隐式转换
5     std::cout << num1 << " " << num2 << std::endl;
6 
7     system("pause");
8 }

//error C2440: “初始化”: 无法从“void *”转换为“int *”

//C风格类型转换

 1 #include <iostream>
 2 using namespace std;
 3 
 4 void main()
 5 {
 6     void *p = new int[10];
 7 
 8     //int *pint = p;//error C2440: “初始化”: 无法从“void *”转换为“int *”
 9 
10     int *pint = (int *)p;//C风格类型转换
11 
12     system("pause");
13 }

6.4.2类型转换函数

带参数的构造函数不能把一个类类型转换成基本类型。

类类型转换函数是一种特殊的成员函数，提供类对象之间显式类型转换的机制。

（实质上通过重载完成） 

语法形式：

X::operator T()

{

......

return T类型的对象

}

功能：将类型X的对象转换为类型T的对象

T可以预定义类型，也可以是用户定义类型。

函数没有参数，没有返回类型，但必须有一条return语句，返回T类型的对象。

该函数只能为成员函数，不能为友元。

//类类之间的转换函数

#include <iostream>

class fushu
{
public:
    explicit fushu(int num)
    {
        x = num;
        y = num;
    }
    void print()
    {
        std::cout << x << " " << y << std::endl;
    }
    operator int();//类类之间的转换函数
private:
    int x;
    int y;
};

fushu::operator int()//类类之间的转换函数
{
    return x + y;
}

void main()
{
    int num(10.9);
    fushu fushu1(num);

    int data = fushu1;

    std::cout << data << std::endl;//20
    
    system("pause");
}

类型转换函数有两种使用方式：

隐式使用 i=a;

显式使用 i=a.operator int();//int(a);(int)a

使用不同函数作类型转换函数：

int i=a;//用类型转换函数进行转换

X i=a;//用构造函数进行转换

小结

运算符重载可以像基本数据类型一样，用间接明确的运算符操作自定义的类对象。

重载运算符函数可以对运算符作出新的解释，但原有的基本语义不变。

运算符重载既可以重载为成员函数，也可以重载为友元函数或普通函数。

当一元运算符的操作数，或者二元运算符的左操作数是类的一个对象时，以成员函数重载；当一个运算符的操作需要改变对象状态时，应该以成员函数重载。如果以友元函数重载，则使用引用参数修改对象。

当运算符的操作数（尤其是第一个操作数）希望有隐式转换，则重载运算符时必须使用友元函数。

构造函数和类型转换函数可以实现基本类型与类类型，以及类类型之间的类型转换。