c++运算符重载和友元函数

1.运算符重载：例如+本来是用于两个整数或者两个浮点数进行相加的，如果我将+重载之后，可将+用于时间对象的相加，比如一个时间对象为1小时50分，一个时间对象为2小时30分，则这样两个时间对象通过重载的+可以直接进行运算得到4小时20分。

2.重载+使得+能直接计算时间和的方法：

只需要在operator后加上运算符号作为函数名即可，如 operator+作为函数名重载+:

class Time
{
    private:
        int hour;
        int minute;
    public:
        Time();
        Time(int h, int m);
        Time operator+(const Time & t);   //重载+，使得+可以直接计算时间对象的和
};

Time Time::operator+(const Time & t)     //实现重载+的函数代码如下
{
    Time sum;
    sum.minute = minute + t.minute;
    sum.hour = hour + t.hour + sum.minute / 60;
    sum.minute %= 60;
    return sum;
}

3.友元函数：不是类的成员函数，但是可以访问类的私有成员变量，其访问权限和成员函数相同。
   友元函数特点：友元函数声明在类中，在声明的时候，需要在函数前加上friend；友元函数的定义中，不能在前面加friend，而且由于友元函数不是类的成员函数，所以前面不要加界定符::

class Time
{
    private:
        int hour;
        int minute;
    public:
        Time();
        Time(int h, int m);
        void reset(int h, int m);
        Time operator+(const Time & t);
        Time operator-(const Time & t);
        Time operator*(const int & a);
        friend Time operator*(const int & a, Time & t);  //友元函数的声明，重载*
        friend std::ostream & operator<<(std::ostream & os, const Time & t);  //友元函数的声明，重载输出符<<
};

4.重载运算符可以通过类的成员函数重载，也可以通过类的非成员函数(一般是友元函数)重载。

  只能通过类的成员函数重载的运算符：

  ●=

  ●()

  ●[]

  ●->

  既可以通过类的成员函数，又可以通过类的非成员函数(一般是友元函数)重载的运算符有：

5.重载<<的固定模板：

一般来说，要重载<<运算符来 显示类c_name的对象，可使用一个友元函数，其定义如下(固定模板)：

ostream & operator<<(ostream & os, const c_name & obj)
{
   os << ... ;   //display object contents
   return os;
}

6.重载>>的方法：

实例：

std::istream & operator>>(std::istream & is, Complex & c)
{
    cout << "Enter the real part: ";
    is >> c.real;
    cout << "Enter the virtual part: ";
    is >> c.vir;
    return is;
}

7.使用运算符重载及友元函数的实例：

文件结构:

time.h代码：

#ifndef TIME_H_INCLUDED
#define TIME_H_INCLUDED

#include <iostream>

class Time
{
    private:
        int hour;
        int minute;
    public:
        Time();
        Time(int h, int m);
        void reset(int h, int m);
        Time operator+(const Time & t);    //使用类成员函数重载+运算符
        Time operator-(const Time & t);
        Time operator*(const int & a);
        friend Time operator*(const int & a, Time & t);  //声明友元函数，使用非类成员函数(友元函数)重载*运算符
        friend std::ostream & operator<<(std::ostream & os, const Time & t);  //声明友元函数，重载<<运算符
};

#endif // TIME_H_INCLUDED

time.cpp代码:

#include <iostream>
#include "time.h"

Time::Time()
{
    hour = 0;
    minute = 0;
}

Time::Time(int h, int m)
{
    hour = h;
    minute = m;
}

void Time::reset(int h, int m)
{
    hour = h;
    minute = m;
}

Time Time::operator+(const Time & t)
{
    Time sum;
    sum.minute = minute + t.minute;
    sum.hour = hour + t.hour + sum.minute / 60;
    sum.minute %= 60;
    return sum;
}

Time Time::operator-(const Time & t)
{
    Time minu;
    if(minute >= t.minute)
    {
        minu.hour = minute - t.hour;
        minu.minute = minute - t.minute;
    }
    else
    {
        minu.minute = minute + 60 - t.minute;
        minu.hour = hour - t.hour - 1;
    }
    return minu;
}

Time Time::operator*(const int & a)
{
    Time result;
    result.minute = minute * a;
    result.hour = hour * a + result.minute / 60;
    result.minute %= 60;
    return result;
}

Time operator*(const int & a, Time & t)         //友元函数定义前不能加friend，而且不加Time::
{
    Time result;
    result.minute = t.minute * a;
    result.hour = t.hour * a + result.minute / 60;
    result.minute %= 60;
    return result;
}

std::ostream & operator<<(std::ostream & os, const Time & t)   //友元函数定以前不加friend，并且不加Time::
{
    std::cout << t.hour << " hours, " << t.minute << " minute.\n";
    return os;
}

main.cpp代码：

#include <iostream>
#include "time.h"
using namespace std;

int main()
{
    Time time1(3, 40);
    Time time2(2, 50);
    Time result1, result2, result3, result4;
    result1 = time1 + time2;
    result2 = time1 - time2;
    result3 = 3* time1;
    result4 = time1 * 3;
    cout << result1;
    cout << result2;
    cout << result3;
    cout << result4;
}