C++中的一元、二元運算符重載

本篇內容主要講解“C++中的一元、二元運算符重載”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“C++中的一元、二元運算符重載”吧!

運算符重載，就是對已有的運算符重新進行定義，賦予其另一種功能，使他適應不同的數據類型。

運算符重載的本質：函數重載       關鍵字：operator

一、一元運算符重載
一元運算符就是對一個數進行操作

一元運算符重載利用成員函數進行重載時，就不用給（）內傳參數了，（）內有隱藏的*this

負號運算符的重載
定義一個Coordinate坐標類，分別通過成員函數和友元函數對負號運算符進行重載

通過成員函數對負號運算符進行重載：

#include<iostream>
using namespace std;
 
/******************************************
一元運算符重載
要求：
定義一個Coordinate坐標類
成員函數：構造、getX、getY，數據成員：m_iX，m_iY
1、負號運算符重載（成員函數，友元函數）
2、++運算符重載（前置++，后置++）
*******************************************/
 
class Coordinate
{
    Coordinate(int x,int y);
 
        //通過成員函數對符號運算符進行重載 
    Coordinate &operator-()；//讓他返回出來的是它本身，這樣才能讓他再進行負號運算符的運算，所以返回值寫成Coordinate &
 
    int getX();
    int getY();
private:
    int m_iX;
    int m_iY;
};
 
Coordinate::Coordinate(int x,int y)
{
    m_iX = x;
    m_iY = y;
}
int Coordinate::getX()
{
    return m_iX;
}
int Coordinate::getY()
{
    return m_iY;
}
 
//成員函數實現負號運算符重載
Coordinate &Coordinate::operator-()
{
    this->m_iX = -(this->m_iX);//m_iX = -m_iX;
    this->m_iY = -(this->m_iY);
 
    return *this;//返回的是一個對象
}
 
 
int main()
{
    Coordinate coor1(1,3);
    cout<<coor1.getX()<<","<<coor1.getY()<<endl;
    -coor1;//coor1.operator-();成員函數
    cout<<coor1.getX()<<","<<coor1.getY()<<endl;
 
    return 0;
}
運行結果：

通過友元函數對負號運算符進行重載：

 
#include<iostream>
using namespace std;
 
/******************************************
一元運算符重載
要求：
定義一個Coordinate坐標類
成員函數：構造、getX、getY，數據成員：m_iX，m_iY
1、負號運算符重載（成員函數，友元函數）
2、++運算符重載（前置++，后置++）
*******************************************/
 
class Coordinate
{
    friend Coordinate &operator-(Coordinate &c);//friend Coordinate &operator-(Coordinate c);
    //()內要傳入參數，其實就是在成員函數重載中要傳入的*this，所以應該是Coordinate的一個對象，為了傳遞效率，也可以傳入一個對象的引用
public:
    Coordinate(int x,int y);
    int getX();
    int getY();
private:
    int m_iX;
    int m_iY;
};
 
Coordinate::Coordinate(int x,int y)
{
    m_iX = x;
    m_iY = y;
}
int Coordinate::getX()
{
    return m_iX;
}
int Coordinate::getY()
{
    return m_iY;
}
 
Coordinate &operator-(Coordinate &c)//友元函數重載符號運算符
{
    c.m_iX = -c.m_iX;
    c.m_iY = -c.m_iY;
 
    return c;
}
 
int main()
{
    Coordinate coor1(1,3);
    cout<<coor1.getX()<<","<<coor1.getY()<<endl;
 
    operator-(coor1);//-coor1；
    cout<<coor1.getX()<<","<<coor1.getY()<<endl;
 
    return 0;
}
運行結果：

前置++、后置++重載
#include<iostream>
using namespace std;
 
Coordinate
{
public:
    Coordinate(int x,int y);
    Coordinate &operator++();//前置++的運算符重載，返回的是一個Coordinate的引用
    Coordinate operator++(int);//后置++的運算符重載，參數int只是為了表示當前的++是后置++
//返回的是一個對象而不是引用，是因為后置++是在下一行代碼再去訪問這個對象的時候才會返回++之后的值，如果返回引用的話，函數結束后，引用就會被釋放
    int getX();
    int getY();
private:
    int m_iX;
    int m_iY;
};
 
Coordinate::Coordinate(int x,int y)
{
    m_iX = x;
    m_iY = y;
}
int Coordinate::getX()
{
    return m_iX;
}
int Coordinate::getY()
{
    return m_iY;
}
 
Coordinate &Coordinate::operator++()//前置++
{
    ++m_iX;
    ++m_iY;
 
    return *this;
}
Coordinate Coordinate::operator++(int)//后置++
{
    Coordinate old(*this);//利用默認拷貝構造函數構造一個臨時對象old，將++之前的值存儲在臨時對象old中
    this->m_iX++;
    this->m_iY++;
 
    return old;//當前這個表達式是他++之前的值，下一行代碼再去訪問這個對象的時候，才是++之后的值
}
 
 
int main()
{
    Coordinate coor1(1,3);
    cout<<coor1.getX()<<","<<coor1.getY()<<endl;//1,3
 
    coor1.operator++(0);//參數0只是標識是后置++
    cout<<coor1.getX()<<","<<coor1.getY()<<endl;//2,4
    
    cout<<(coor1++).getX()<<",";//2
    cout<<(coor1++).getY()<<endl;//5
 
    return 0;
}
運行結果：

二、二元運算符重載
1、“+號”運算符重載(成員函數，友元函數)
2、“<<”輸出運算符重載
3、“[]索引”運算符重載

#include<iostream>
using namespace std;
 
/******************************************
二元運算符重載
要求：
定義一個Coordinate坐標類
成員函數：構造、getX、getY，數據成員：m_iX，m_iY
1、“+號”運算符重載(成員函數，友元函數)
2、“<<”輸出運算符重載
3、“[]索引”運算符重載
*******************************************/
 
class Coordinate
{
    //“<<”輸出運算符重載
    friend ostream& operator<<(ostream &output,const Coordinate &c);//返回值是ostream
 
    //“+號”運算符通過友元函數重載
    friend Coordinate operator+(const Coordinate &c1,const Coordinate &c2);
public:
    Coordinate(int x,int y);
 
    //“+號”運算符通過成員函數重載，不能傳引用，要傳對象
    //Coordinate operator+(const Coordinate &c);
 
    //“[]索引”運算符重載
    int operator[](int index);
 
    int getX();
    int getY();
private:
    int m_iX;
    int m_iY;
};
 
Coordinate::Coordinate(int x,int y)
{
    m_iX = x;
    m_iY = y;
}
int Coordinate::getX()
{
    return m_iX;
}
int Coordinate::getY()
{
    return m_iY;
}
 
/*“+號”運算符通過成員函數重載
Coordinate Coordinate::operator+(const Coordinate &c)
{
    Coordinate temp(0,0);
    temp.m_iX = this->m_iX + c.m_iX;
    temp.m_iY = this->m_iY + c.m_iY;
    return temp;
}
*/
 
//“+號”運算符通過友元函數重載
Coordinate operator+(const Coordinate &c1,const Coordinate &c2)
{
    Coordinate temp(0,0);
    temp.m_iX = c1.m_iX + c2.m_iX;
    temp.m_iY = c1.m_iY + c2.m_iY;
 
    return temp;
}
 
//“<<”輸出運算符重載
ostream& operator<<(ostream &output,const Coordinate &c)//返回值為ostream&,const Coordinate &c為要進行輸出的對象
{
    output<<c.m_iX<<","<<c.m_iY<<endl;
    return output;
}
 
//“[]索引”運算符重載
int Coordinate::operator[](int index)
{
    if(0 == index)
    {
        return m_iX;
    }
    if(1 == index)
    {
        return m_iY;
    }
}
 
int main()
{
    Coordinate coor1(1,3);
    Coordinate coor2(2,4);
    Coordinate coor3(0,0);
    coor3 = operator+(coor1,coor2);
    //coor3 = coor1 + coor2;
    cout<<coor3.getX()<<","<<coor3.getY()<<endl;//3,7
 
    operator<<(cout,coor1);//1，3
    cout<<coor2;//2，4
 
    cout<<coor2[0];//2
    cout<<coor2[1];//4
 
    return 0;
}
運行結果：

注：

“<<”輸出運算符重載不能用成員函數進行重載，只能用友元函數進行重載；因為在成員函數中重載第一個參數為隱藏的*this，而“<<”輸出運算符重載第一個參數為ostream &output
“[]索引”運算符重載不能用友元函數進行重載，只能用成員函數進行重載；因為“[]索引”運算符重載第一個參數必須為*this，通過*this才能訪問到該對象的數據
賦值運算符重載函數不能被繼承
因為相較于基類，派生類往往要添加一些自己的數據成員和成員函數，如果允許派生類繼承基類的賦值運算符重載函數，那么，在派生類不提供自己的賦值運算符重載函數時，就只能調用基類的，但基類版本只能處理基類的數據成員，在這種情況下，派生類自己的數據成員怎么辦？                        所以，C++規定，賦值運算符重載函數不能被繼承。

賦值運算符重載函數只能是類的非靜態的成員函數,不能是靜態成員函數，也不能是友元函數
 

其實，之所以不是靜態成員函數，是因為靜態成員函數只能操作類的靜態成員，不能操作非靜態成員。如果我們將賦值運算符重載函數定義為靜態成員函數，那么，該函數將無法操作類的非靜態成員，這顯然是不可行的。

到此，相信大家對“C++中的一元、二元運算符重載”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！