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;
}