C++运算符重载

C++运算符重载

一、什么是重载？

函数重载：统一作用域内名字相同，形参列表不同的函数。
运算符重载：当运算符作用于类类型的运算对象时，重新定义该运算符的含义。

二、可重载与不可重载运算符

可以被重载的运算符

+	-	*	/	%	^
&	|	~	!	`	=
<	>	<=	>=	++	–
<<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
|=	*=	<<=	>>=	[]	()
->	->*	new	new[]	delete	delete[]

不能被重载的运算符

::	.*	.	?:

运算符重载注意事项

1. 重载运算符函数的参数数量与其作用的对象数量一样多。
   1. 对于二元运算符来说，左侧运算对象传递给第一个参数，右侧运算对象传递给第二个参数；
   2. 除重载的函数调用运算符operator()外，其他重载运算符不能含有默认实参。
2. 如果一个运算符函数是成员函数，则它的第一个（左侧）运算对象绑定到隐式的this指针上，因此，成员运算符的（显式）参数数量比运算符的运算对象总数少一个。
3. 运算符函数或是类成员，或至少含有一个类类型的参数（当运算符作用于内置类型对象时，我们无法改变该运算符的含义）。

三、结合代码认识运算符重载

#include<iostream>
class MyNum
{
public:
    MyNum(){ m_int = 0; m_float = 0; };
    MyNum(int a_int, float a_float):m_int(a_int),m_float(a_float){}
    ~MyNum(){};
public:
    friend std::ostream& operator<<(std::ostream& os, const MyNum& obj);
    friend std::istream& operator>>(std::istream& is, MyNum& obj);
    friend bool operator==(const MyNum& lobj, const MyNum& robj);
public:
    bool operator!=(const MyNum& obj);
    MyNum& operator++();
    MyNum operator++(int);
private:
    int m_int;
    float m_float;
};

std::ostream& operator<<(std::ostream& os, const MyNum& obj)
{
    os << " m_int = " << obj.m_int << ", m_float = " << obj.m_float << ".";
    return os;
}

std::istream& operator>>(std::istream& is, MyNum& obj)
{
    is >> obj.m_int >> obj.m_float;
    if(is)
    {
        //input success
    }
    else
    {   // input failed, do default operation
        obj.m_int = 0;
        obj.m_float = 0;
    }
    return is;
}

bool operator==(const MyNum& lobj, const MyNum& robj)
{
    float tmp = lobj.m_float - robj.m_float;
    if(lobj.m_int == robj.m_int && 0.0001 > (tmp > 0 ? tmp : -tmp))//self-defined precision
    {
        return true;
    } 
    return false;
}

bool MyNum::operator!=(const MyNum& obj)
{
    float tmp = m_float - obj.m_float;
    if(m_int == obj.m_int && 0.0001 < (tmp > 0 ? tmp : -tmp))
    {
        return true;
    }
    return false;
}

MyNum& MyNum::operator++()
{
    m_float += 1.0;
    m_int++;
    return *this;
}

MyNum MyNum::operator++(int)
{
    MyNum ret(m_int,m_float);
    m_float += 1.0;
    m_int++;
    return ret;
}

int main()
{
    MyNum num1(12,0.3),num2,num3;
    std::cin >> num2 >> num3;
    std::cout << num1 << std::endl;
    if(num2 == num1)
        std::cout << " num2 equals num1 " << std::endl;
    else
        std::cout << " num2 differs num1 " << std::endl;
    if(num3 == num1)
        std::cout << " num3 equals num1 " << std::endl;
    else 
        std::cout << " num3 differs num1 " << std::endl;
    std::cout << num1++ << std::endl;
    std::cout << num1 << std::endl;
    return 0;
}

代码效果

[pig@localhost OperatorOverried]$ g++ OperatorOverride.cpp 
[pig@localhost OperatorOverried]$ ./a.out 
12 0.1 
12 0.3
 m_int = 12, m_float = 0.3.
 num2 differs num1 
 num3 equals num1 
 m_int = 12, m_float = 0.3.
 m_int = 13, m_float = 1.3.
[pig@localhost OperatorOverried]$ 

处理方式	原因
输入输出作为友元	输入输出运算符必须是普通的非成员函数，否则他的左侧（<<)运算对象将是对应的类类型对象
两个自增运算符的形参列表不同	为了区分前置与后置自增，后置版本接受一个额外的（不被使用）int型形参
两个自增运算符的返回类型不同	与内置版本返回类型保持一致，前置返回引用，后置返回对象

输入输出运算符重载的部分细节

1. 通常，输出运算符的第一个形参为非常量(向流写入内容将改变其状态)ostream对象引用(我们无法直接复制一个ostream对象)。
2. 第二个形参一般为我们想要打印的类型的常量(打印动作不会改变对象内容)的引用(避免复制实参)。
3. 为了与其他输出运算符保持一致，operator<<一般返回它的ostream形参。

输入输出运算符重载的部分注意

1. 输出运算符主要打印对象的内容，而非控制格式，其不应该打印换行符。
2. 输入运算符必须处理输入可能失败的情况，而输出运算符不需要。

---

文中有不当之处，还望帮忙指正，谢谢喽^ - ^……