C++_運算符重載總結

時間 2019-11-17

標籤 c++ 運算符重載總結欄目 C&C++ 简体版

原文原文鏈接

什麼是運算符的重載?ios

運算符與類結合，產生新的含義。程序員

爲何要引入運算符重載？數組

做用：爲了實現類的多態性(多態是指一個函數名有多種含義)函數

怎麼實現運算符的重載？this

方式：類的成員函數或友元函數（類外的普通函數）spa

規則：不能重載的運算符有 . 和 .* 和 ?: 和 :: 和 sizeofcode

友元函數和成員函數的使用場合：通常狀況下，建議一元運算符使用成員函數，二元運算符使用友元函數對象

一、運算符的操做須要修改類對象的狀態，則使用成員函數。如須要作左值操做數的運算符（如=，+=，++）blog

二、運算時，有數和對象的混合運算時，必須使用友元ci

三、二元運算符中，第一個操做數爲非對象時，必須使用友元函數。如輸入輸出運算符<<和>>

具體規則以下：

運算符	建議使用
全部一元運算符	成員函數
＝ ( ) [ ] ->	必須是成員函數
+= -= /= *= ^= &= != %= >>= <<= , 彷佛帶等號的都在這裏了	成員函數
全部其它二元運算符, 例如: –,+,*,/	友元函數
<< >>	必須是友元函數

2. 參數和返回值

當參數不會被改變，通常按const引用來傳遞(如果使用成員函數重載，函數也爲const).

對於返回數值的決定:

1) 若是返回值可能出如今=號左邊, 則只能做爲左值, 返回非const引用。

2) 若是返回值只能出如今=號右邊, 則只需做爲右值, 返回const型引用或者const型值。

3) 若是返回值既可能出如今=號左邊或者右邊, 則其返回值須做爲左值, 返回非const引用。

運算符重載舉例：

+和 -運算符的重載：

class Point  
{  
private:  
    int x; 
public:  
    Point(int x1)
    {      x=x1;}  
    Point(Point& p)   
    {      x=p.x;}
    const Point operator+(const Point& p);//使用成員函數重載加號運算符
    friend const Point operator-(const Point& p1,const Point& p2);//使用友元函數重載減號運算符
};  

const Point Point::operator+(const Point& p)
{
    return Point(x+p.x);
}

Point const operator-(const Point& p1,const Point& p2)
{
    return Point(p1.x-p2.x);
}

調用:

Point a(1);  
Point b(2);
a+b;  //正確，調用成員函數
a-b;  //正確，調用友元函數
a+1;  //正確，先調用類型轉換函數，把1變成對象，以後調用成員函數
a-1;  //正確，先調用類型轉換函數，把1變成對象，以後調用友元函數
1+a;  //錯誤，調用成員函數時，第一個操做數必須是對象，由於第一個操做數還有調用成員函數的功能
1-a;  //正確，先類型轉換 後調用友元函數

總結：

一、因爲+ -都是出如今=號的右邊，如c=a+b，即會返回一個右值，能夠返回const型值
二、後幾個表達式討論的就是，數和對象混合運算符的狀況，通常出現這種狀況，常使用友元函數

三、雙目運算符的重載：

重載運算符函數名：operator@(參數表)

隱式調用形式：obj1+obj2

顯式調用形式：obj1.operator+(OBJ obj2)---成員函數

operator+(OBJ obj1，OBJ obj2)---友元函數

執行時，隱式調用形式和顯式調用形式都會調用函數operator+()

++和--運算符的重載：

class Point  
{  
private:  
    int x; 
public:  
    Point(int x1)
    {      x=x1;}  
    Point operator++();//成員函數定義自增
    const Point operator++(int x); //後綴能夠返回一個const類型的值
    friend Point operator--(Point& p);//友元函數定義--
    friend const Point operator--(Point& p,int x);//後綴能夠返回一個const類型的值
};  

Point Point::operator++()//++obj
{
    x++;
    return *this;
}
const Point Point::operator++(int x)//obj++
{
    Point temp = *this;
    this->x++;
    return temp;
}
Point operator--(Point& p)//--obj
{
    p.x--;
    return p;
         //前綴形式(--obj)重載的時候沒有虛參,經過引用返回*this 或 自身引用,也就是返回變化以後的數值
}
const Point operator--(Point& p,int x)//obj--
{
    Point temp = p;
    p.x--;
    return temp;
         // 後綴形式obj--重載的時候有一個int類型的虛參, 返回原狀態的拷貝
}

函數調用：

Point b(2);
a++;//隱式調用成員函數operator++(0),後綴表達式
++a;//隱式調用成員函數operator++(),前綴表達式
b--;//隱式調用友元函數operator--(0),後綴表達式
--b;//隱式調用友元函數operator--(),前綴表達式
cout<<a.operator ++(2);//顯式調用成員函數operator ++(2)，後綴表達式
cout<<a.operator ++();//顯式調用成員函數operator ++()，前綴表達式
cout<<operator --(b,2);//顯式調用友元函數operator --(2)，後綴表達式
cout<<operator --(b);//顯式調用友元函數operator --()，前綴表達式 </pre>

總結：

一、a++

函數返回：temp(臨時變量)

函數返回是不是const類型：返回是一個拷貝後的臨時變量)，不能出如今等號的左邊(臨時變量不能作左值)，函數的結果只能作右值，則要返回一個const類型的值

++a

函數返回：*this;

函數返回是不是const類型：返回原狀態的自己，返回值能夠作左值，即函數的結果能夠作左值，則要返回一個非const類型的值

二、先後綴僅從函數名(operator++)沒法區分，只能有參數區分，這裏引入一個虛參數int x，x能夠是任意整數。

三、單目運算符的重載：

重載運算符函數名：operator@(參數表)

隱式調用形式：obj1@ 或 @obj1

顯式調用形式：

成員函數:

obj1.operator@( )//前綴

obj1.operator@(0)//後綴

友元函數:

operator@(OBJ obj)//前綴

operator@(OBJ obj,int x)//後綴

執行時，隱式調用形式和顯式調用形式都會調用函數operator@()

重載下標運算符[ ]

class Point  
{  
private:  
    int x[5]; 
public:  
    Point()
    {
        for (int i=0;i<5;i++)
        {
            x[i]=i;
        }
    } 
    int& operator[](int y);
};  
int& Point::operator[](int y)
{
    static int t=0;
    if (y<5)
    {
        return x[y];
    }
    else
    {
        cout<<"下標出界";
        return t;
    }    
}

調用：

Point a;
for (int i=0;i<10;i++)
{
         cout<<a[i]<<endl;//不管i下標是否越界，每當使用a[i]時，都會調用[]的重載
}
a[0]=10;

重載下標運算符[ ]的目的：

一、對象[x] 相似於數組名[x]，更加符合習慣

二、能夠對下標越界做出判斷

語法：

重載方式：只能使用成員函數重載

函數名：operator[ ](參數表)

參數表：一個參數，且僅有一個參數，該參數設定了下標值，一般爲整型，可是也能夠爲字符串( 當作下標)。

函數調用：顯式調用：Obj[arg]-對象[下標]

隱式調用：obj.operator[ ](arg)

返回類型：

一、返回函數引用 + 返回成員的實際類型（由程序員根據函數體定義）

二、由於返回值能夠作左值和右值，應該不使用返回值爲const類型

可是，爲了能訪問const對象，下標運算符重載有非const和const兩個版本。（待定寫）

如：int& Point::operator[](int y)//爲何使用返回引用：返回的值能夠作左值，也能夠作右值，則必須使用返回引用

重載運算符( )

class Point  
{  
private:  
    int x; 
public:  
    Point(int x1)
    {      x=x1;}  
    const int operator()(const Point& p);
};  

const int Point::operator()(const Point& p)
{
    return (x+p.x);
}

調用：

調用：
Point a(1);
Point b(2);
cout<<a(b);

重載運算符( )的目的：

一、對象( ) 相似於函數名(x)，更加符合習慣

語法：

重載方式：只能使用成員函數重載

重載後還能夠繼續重載

函數名：operator( )(參數表)

參數表：參數隨意，具體根據實際狀況而定。

函數調用：顯式調用：Obj(x)

隱式調用：obj.operator( )(x)

返回類型：

一、返回成員的實際類型隨意，具體由程序員根據函數體定義

二、由於返回值只能作右值，只讀，應該使用返回值爲const類型

重載輸入輸出操做符<< >>

class Point  
{  
private:  
    int x; 
public:  
    Point(int x1)
    {      x=x1;} 
    friend ostream& operator<<(ostream& cout,const Point& p);//使用友元函數重載<<輸出運算符
    friend istream& operator>>(istream& cin,Point& p);//使用友元函數重載>>輸出運算符
};  
ostream& operator<<(ostream& cout,const Point& p)
{
    cout<<p.x<<endl;
    return cout;
}
istream& operator>>(istream& cin,Point& p)
{
    cin>>p.x;
    return cin;
}

調用：
Point a(1);
Point b(2);
cin>>a>>b;
cout<<a<<b<<endl;

語法：

重載方式：只能使用友元函數重載且使用三個引用&

函數名：

輸出流： operator<<(參數表)

輸入流：operator>>(參數表)

參數表：固定（容易出錯啊），兩個參數均用引用&

輸出流：必須是兩個參數：對輸出流ostream& 和對象

第一個操做數cout，定義在文件iostream中，是標準類類型ostream的對象的引用。

如：ostream& cout,const Point& p

輸入流：必須是兩個參數：對輸入流ostream& 和對象

第一個操做數是cin，定義在文件iostream，其實是標準類類型istream的對象的引用

如：instream& cin,const Point& p

函數調用：

輸出流：顯式調用：cout<<對象

隱式調用： operator<<(cout，對象)

輸入流：顯式調用：cin>>對象

隱式調用： operator>>(cin，對象)

返回類型：返回類型固定 + 使用返回函數引用（知足連續輸出）

輸出流：返回ostream&

如：ostream& operator<<(ostream& cout,const Point& p)

輸入流：返回：istream&

如：istream& operator>>(istream& cin,Point& p)

注意：爲何輸入輸出操做符的重載必須使用友元函數？

由於：成員函數要求是有對象調用，則第一個參數必須是類的對象，可是<<和>>第一個參數是流的對象引用。

故，不能使用成員函數。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

C++_運算符重載 總結

C++_運算符重載總結