c++之运算符重载基础

1、  定义：所谓重载，就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义，使之实现新功能，因此，一个函数名就可以用来代表不同功能的函数，也就是”一名多用”。

2、为什么会用运算符重载机制：

用复数类举例：Complex c3 = c1 + c2;

原因 Complex是用户自定义类型，编译器根本不知道如何进行加减编译器给提供了一种机制，让用户自己去完成，自定义类型的加减操作，这个机制就是运算符重载机制，运算符重载的本质是一个函数。

3、运算符重载基础

（1）运算符重载的两种方法：类成员函数和全局函数

1）二元运算符的重载（+、-、*、/等运算符）（以下均用类成员函数重载）

#include <stdio.h>class test1_1{public:test1_1(int a);int operator+(test1_1 &obj);int operator+(const int a);int operator-(test1_1 &obj);int operator-(const int a);int operator*(test1_1 &obj);int operator*(const int a);int operator/(test1_1 &obj);int operator/(const int a);private:int m_a;};test1_1::test1_1(int a){m_a = a;}int test1_1::operator+(test1_1 &obj){return (m_a + obj.m_a);}int test1_1::operator+(const int a){return (m_a + a);}int test1_1::operator-(test1_1 &obj){return (m_a - obj.m_a);}int test1_1::operator-(const int a){return (m_a - a);}int test1_1::operator*(test1_1 &obj){return (m_a * obj.m_a);}int test1_1::operator*(const int a){return (m_a * a);}int test1_1::operator/(test1_1 &obj){return (m_a / obj.m_a);}int test1_1::operator/(const int a){return (m_a / a);}int main1_1(){test1_1 a1(10), a2(20);int c = a1 * a2;printf("c = %d\n", c);return 0;}

2）一目运算符的重载（++、--等）（以下均用全局函数重载）

#include <stdio.h>class test4_1{friend test4_1 operator++(test4_1 &obj);friend test4_1 operator++(test4_1 &obj, int);friend test4_1 operator--(test4_1 &obj);friend test4_1 operator--(test4_1 &obj, int);public:test4_1(){}test4_1(int a, int b){this->a = a;this->b = b;}void print(){printf("%d + %di\n", this->a, this->b);}private:int a;int b;};test4_1 operator++(test4_1 &obj){obj.a++;obj.b++;return obj;}test4_1 operator++(test4_1 &obj, int){test4_1 tmp(obj.a, obj.b);obj.a++;obj.b++;return tmp;}test4_1 operator--(test4_1 &obj){obj.a--;obj.b--;return obj;}test4_1 operator--(test4_1 &obj, int){test4_1 tmp(obj.a, obj.b);obj.a--;obj.b--;return tmp;}int main4_1(){test4_1 t1(10, 20), t2;t1++;++t1;t1--;--t1;t1.print();return 0;}

（2）定义运算符重载函数名步骤：全局函数、类成员函数方法实现运算符重载步骤

      1）要承认操作符重载是一个函数，写出函数名称operator+ ()

   2）根据操作数，写出函数参数

      3）根据业务，完善函数返回值(看函数是返回引用还是指针 元素)，及实现函数业务

（3）友元函数实现操作符重载应用场景

        1）友元函数和成员函数选择方法：

①当无法修改左操作数的类时，使用全局函数进行重载

②=, [], ()和->操作符只能通过成员函数进行重载

       2）用友元函数重载<< 运算符

#include <iostream>using namespace std;class test5_1{friend ostream & operator<<(ostream &out, test5_1 &obj);public:test5_1(int a){this->a = a;}void print(){printf("a = %d\n", this->a);}private:int a;};ostream & operator<<(ostream &out, test5_1 &obj){out << obj.a << endl;return out;}int main5_1(){test5_1 t1(10);cout << t1;cout << endl;return 0;}

（4）友元函数重载操作符使用注意点

    1）友员函数重载运算符常用于运算符的左右操作数类型不同的情况

      2）在第一个参数需要隐式转换的情形下，使用友员函数重载运算符是正确的选择

   3）友员函数没有 this 指针，所需操作数都必须在参数表显式声明，很容易实现类型的隐式转换

4）C++中不能用友员函数重载的运算符有：=、（）、［］、－>

 

4、不要重载 && 和 || 运算符

1）&&和||内置实现了短路规则

2）操作符重载是靠函数重载来完成的

3）C++的函数参数都会被求值，无法实现短路规则

#include <cstdlib>#include <iostream> using namespace std; class Test{    int i;public:    Test(int i)    {        this->i = i;    }     Test operator+ (const Test& obj)    {        Test ret(0);         cout<<"执行+号重载函数"<<endl;        ret.i = i + obj.i;        return ret;    }     bool operator&& (const Test& obj)    {        cout<<"执行&&重载函数"<<endl;         return i && obj.i;    }}; // && 从左向右int main(){    int a1 = 0;    int a2 = 1;     cout<<"注意：&&操作符的结合顺序是从左向右"<<endl;     if( a1 && (a1 + a2) )    {        cout<<"有一个是假，则不在执行下一个表达式的计算"<<endl;    }     Test t1 = 0;    Test t2 = 1;     //if( t1 && (t1 + t2)  )    //t1  && t1.operator+(t2)    // t1.operator&&(  t1.operator+(t2) )     //1 && || 重载他们 不会产生短路效果    if(  (t1 + t2) && t1)    {        //t1.operator+(t2) && t1;        //(t1.operator+(t2)).operator&&(t1);         cout<<"两个函数都被执行了，而且是先执行了+"<<endl;    }     //2 && 运算符的结合性    // 两个逻辑与运算符  在一块的时候, 采去谈 运算符的结合性    // 从左到右    (t1 + t2) && t1 ; 运算结果 && t2)    //if(  (t1 + t2) && t1 && t2)    {        //t1.operator+(t2) && t1;        //(t1.operator+(t2)).operator&&(t1);         cout<<"两个函数都被执行了，而且是先执行了+"<<endl;    }     return 0;}