C++学习笔记4——类的封装（2）

简介：

　　重载的运算符是具有特殊名字的函数：它们的名字由关键字operator和其后要定义的运算符号共同组成。其中一元运算符有一个参数，二元运算符有两个参数。

可以被重载的运算符
+	-	*	/	%	^
&	|	~	!	,	=
<	>	<=	>=	++	--
<<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
|=	*=	<<=	>>=	[]	()
->	->*	new	new[]	delete	delete[]
不能被重载的运算符
：：	.*	.	? :

PS:

　　&&和||运算符无法实现短路保护。

类型：

　　定义运算符重载时可定义为成员函数或者普通的非成员函数。

判断依据：

　　1、赋值（=）、下标（[]）、调用（（））和成员访问箭头（->）运算符必须是成员。

　　2、复合赋值运算符一般来说是成员，但并非必须。

　　3、改变对象状态的运算符或者与给定类型密切相关的运算符，如递增、递减和解引用运算符通常应该是成员。

　　4、具有对称性的运算符可能转换任意一端的运算对象，例如算数、相等性、关系和位运算符等，通常应该是普通非成员函数。

　　5、输入和输出运算符必须是非成员函数。

Demo:

#pragma once
#ifndef _COMPLEXNUMBER_
#define _COMPLEXNUMBER_

#include <iostream>

class complexNum
{
    friend std::ostream& operator<<(std::ostream &out, complexNum &rhs);
    friend std::istream& operator>>(std::istream &in, complexNum &rhs);

public:
    complexNum(int real = , int image = );
    complexNum(const complexNum &obj);

public:
    complexNum& operator=(const complexNum &rhs);

    complexNum operator+(const complexNum &rhs);

    complexNum& operator++(void);     //前置++
    complexNum operator++(int);       //后置++,需要一个int的占位符
    complexNum& operator+=(const complexNum &rhs);
    bool operator>(const complexNum &rhs);

private:
    int real;
    int image;
};

#endif

#include "complexNumber.h"

complexNum::complexNum(int real, int image) :real(real), image(image){}

complexNum::complexNum(const complexNum &obj) : real(obj.real), image(obj.image){}

std::ostream& operator<<(std::ostream &out, complexNum &rhs)
{
    out << rhs.real;

    if (rhs.image >= )
        out << "+";

    out << rhs.image << "i" << std::endl;

    return out;
}

std::istream& operator>>(std::istream &in, complexNum &rhs)
{
    return in >> rhs.real >> rhs.image;
}

complexNum& complexNum::operator=(const complexNum &rhs)
{
    this->real = rhs.real;
    this->image = rhs.image;

    return *this;
}

complexNum complexNum::operator+(const complexNum &rhs)
{
    complexNum tmp;

    tmp.real = this->real + rhs.real;
    tmp.image = this->image + rhs.image;

    return tmp;
}

complexNum& complexNum::operator++(void)
{
    this->real++;
    this->image++;

    return *this;
}

complexNum complexNum::operator++(int)
{
    complexNum tmp = *this;

    this->real++;
    this->image++;

    return tmp;
}

complexNum& complexNum::operator+=(const complexNum &rhs)
{
    this->operator+(rhs);

    return *this;
}

bool complexNum::operator>(const complexNum &rhs)
{
    if (this->real > rhs.real)
        return true;
    else if (this->real < rhs.real)
        return false;
    else
    {
        if (this->image > rhs.image)
            return true;
        else
            return false;
    }
}