運算符重載為成員函數
重載為類成員的運算符函數定義形式
-
函數類型
operator 運算符（形參）
-
{
-
......
-
}
-
參數個數=原操作數個數-
1 （后置++、--除外）
雙目運算符重載規則
- 如果要重載 B 為類成員函數，使之能夠實現表達式 oprd1 B oprd2，其中 oprd1 為A 類對象，則 B 應被重載為 A 類的成員函數，形參類型應該是 oprd2 所屬的類型。
- 經重載后，表達式 oprd1 B oprd2 相當於 oprd1.operator B(oprd2)
例：復數類加減法運算重載為成員函數
- 要求:
- 將+、-運算重載為復數類的成員函數。
- 規則:
- 實部和虛部分別相加減。
- 操作數:
- 兩個操作數都是復數類的對象。
源代碼：
-
#include <iostream>
-
using
namespace
std;
-
class Complex {
-
public:
-
Complex(
double r =
0.0,
double i =
0.0) : real(r), imag(i) { }
-
//運算符+重載成員函數
-
Complex
operator + (
const Complex &c2)
const;
-
//運算符-重載成員函數
-
Complex
operator - (
const Complex &c2)
const;
-
void display() const;
//輸出復數
-
private:
-
double real;
//復數實部
-
double imag;
//復數虛部
-
};
-
例 復數類加減法運算重載為成員函數
-
Complex Complex::
operator+(
const Complex &c2)
const{
-
//創建一個臨時無名對象作為返回值
-
return Complex(real+c2.real, imag+c2.imag);
-
}
-
-
Complex Complex::
operator-(
const Complex &c2)
const{
-
//創建一個臨時無名對象作為返回值
-
return Complex(real-c2.real, imag-c2.imag);
-
}
-
-
void Complex::display()
const {
-
cout<<
"("<<real<<
", "<<imag<<
")"<<
endl;
-
}
-
例：復數類加減法運算重載為成員函數
-
int main() {
-
Complex c1(5, 4), c2(2, 10), c3;
-
cout <<
"c1 = "; c1.display();
-
cout <<
"c2 = "; c2.display();
-
c3 = c1 - c2;
//使用重載運算符完成復數減法
-
cout <<
"c3 = c1 - c2 = "; c3.display();
-
c3 = c1 + c2;
//使用重載運算符完成復數加法
-
cout <<
"c3 = c1 + c2 = "; c3.display();
-
return
0;
-
}
運算符重載為非成員函數
有些運算符不能重載為成員函數，例如二元運算符的左操作數不是對象，或者是不能由我們重載運算符的對象
運算符重載為非成員函數的規則
- 函數的形參代表依自左至右次序排列的各操作數。
- 重載為非成員函數時
- 參數個數=原操作數個數（后置++、--除外）
- 至少應該有一個自定義類型的參數。
- 后置單目運算符 ++和--的重載函數，形參列表中要增加一個int，但不必寫形參名。
- 如果在運算符的重載函數中需要操作某類對象的私有成員，可以將此函數聲明為該類的友元。
運算符重載為非成員函數的規則
- 雙目運算符 B重載后，
表達式oprd1 B oprd2
等同於operator B(oprd1,oprd2 )
- 前置單目運算符 B重載后，
表達式 B oprd
等同於operator B(oprd )
- 后置單目運算符 ++和--重載后，
表達式 oprd B
等同於operator B(oprd,0 )
例 重載Complex的加減法和“<<”運算符為非成員函數
• 將+、-（雙目）重載為非成員函數，並將其聲明為復數類的友元，兩個操作數都是復數類的常引用。 • 將<<（雙目）重載為非成員函數，並將其聲明為復數類的友元，它的左操作數是std::ostream引用，右操作數為復數類的常引用，返回std::ostream引用，用以支持下面形式的輸出：
cout << a << b;
該輸出調用的是：
operator << (operator << (cout, a), b);
源代碼：
-
#include <iostream>
-
using
namespace
std;
-
-
class Complex {
-
public:
-
Complex(
double r =
0.0,
double i =
0.0) : real(r), imag(i) { }
-
friend Complex
operator+(
const Complex &c1,
const Complex &c2);
-
friend Complex
operator-(
const Complex &c1,
const Complex &c2);
-
friend ostream &
operator<<(ostream &out,
const Complex &c);
-
private:
-
double real;
//復數實部
-
double imag;
//復數虛部
-
};
-
-
Complex
operator+(
const Complex &c1,
const Complex &c2){
-
return Complex(c1.real + c2.real, c1.imag + c2.imag);
-
}
-
Complex
operator-(
const Complex &c1,
const Complex &c2){
-
return Complex(c1.real - c2.real, c1.imag - c2.imag);
-
}
-
-
ostream &
operator<<(ostream &out,
const Complex &c){
-
out <<
"(" << c.real <<
", " << c.imag <<
")";
-
return out;
-
}
-
-
int main() {
-
Complex c1(5, 4), c2(2, 10), c3;
-
cout <<
"c1 = " << c1 <<
endl;
-
cout <<
"c2 = " << c2 <<
endl;
-
c3 = c1 - c2;
//使用重載運算符完成復數減法
-
cout <<
"c3 = c1 - c2 = " << c3 <<
endl;
-
c3 = c1 + c2;
//使用重載運算符完成復數加法
-
cout <<
"c3 = c1 + c2 = " << c3 <<
endl;
-
return
0;
-
}
前置單目運算符重載規則
- 如果要重載 U 為類成員函數，使之能夠實現表達式 U oprd，其中 oprd 為A類對象，則 U 應被重載為 A 類的成員函數，無形參。
- 經重載后，表達式 U oprd 相當於 oprd.operator U()
后置單目運算符 ++和--重載規則
- 如果要重載 ++或--為類成員函數，使之能夠實現表達式 oprd++ 或 oprd-- ，其中 oprd 為A類對象，則 ++或-- 應被重載為 A 類的成員函數，且具有一個 int 類型形參。
- 經重載后，表達式 oprd++ 相當於 oprd.operator ++(0)
重載前置++和后置++為時鍾類成員函數
- 前置單目運算符，重載函數沒有形參
- 后置++運算符，重載函數需要有一個int形參
- 操作數是時鍾類的對象。
實現時間增加1秒鍾。
-
#include <iostream>
-
using
namespace
std;
-
class Clock {
//時鍾類定義
-
public:
-
Clock(
int hour =
0,
int minute =
0,
int second =
0);
-
void showTime() const;
-
//前置單目運算符重載
-
Clock&
operator ++ ();
-
//后置單目運算符重載
-
Clock
operator ++ (
int);
-
private:
-
int hour, minute, second;
-
};
-
-
Clock::Clock(
int hour,
int minute,
int second) {
-
if (
0 <= hour && hour <
24 &&
0 <= minute && minute <
60
-
&&
0 <= second && second <
60) {
-
this->hour = hour;
-
this->minute = minute;
-
this->second = second;
-
}
else
-
cout <<
"Time error!" <<
endl;
-
}
-
void Clock::showTime()
const {
//顯示時間
-
cout << hour <<
":" << minute <<
":" << second <<
endl;
-
}
-
-
//依次重載前置++和后置++為時鍾類成員函數定義
-
Clock & Clock::
operator ++ () {
-
second++;
-
if (second >=
60) {
-
second -=
60; minute++;
-
if (minute >=
60) {
-
minute -=
60; hour = (hour +
1) %
24;
-
}
-
}
-
return *
this;
-
}
-
-
Clock Clock::
operator ++ (
int) {
-
//注意形參表中的整型參數
-
Clock old = *
this;
-
++(*
this);
//調用前置“++”運算符
-
return old;
-
}
-
int main() {
-
Clock myClock(23, 59, 59);
-
cout <<
"First time output: ";
-
myClock.showTime();
-
cout <<
"Show myClock++: ";
-
(myClock++).showTime();
-
cout <<
"Show ++myClock: ";
-
(++myClock).showTime();
-
return
0;
-
}
Clock Clock::operator ++ (int)這個函數表示后置++，函數內部定義了一個局部變量old，在其生存期結束時會被釋放掉，故不能使用返回引用的定義，否則會指向被釋放掉的內存空間中的不確定的值。無論重復使用多少次后置++運算，也只會改變一次原有myclock對象的值（例如myclock++++++因為只有第一次++時*this表示myclock對象，后面都是old對象，就算使用引用也是一樣的，更何況沒使用引用無法連續賦值）。
Clock &Clock::operator ++ (int)這個函數表示前置++，返回的是當前對象的引用，故多次調用前置++運算符時，會一直對對象myclock進行賦值。如果取消引用符號，(++++++myclock).show還是會顯示三次自增后的結果，究其原因是保存的一個臨時變量副本，但myclock依然是只有一次自增的結果，這種情況充分說明了引用&能使返回對象為左值。
上述程序運行結果
改動下main函數：
-
int main() {
-
Clock myClock(23, 59, 59);
-
cout <<
"First time output: ";
-
myClock.showTime();
-
cout <<
"Show myClock++: ";
-
(myClock++++++).showTime();
-
myClock.showTime();
-
cout <<
"Show ++myClock: ";
-
(++++++myClock).showTime();
-
myClock.showTime();
-
-
system(
"pause");
-
return
0;
-
}
結果如下：
*this表示當前對象，Clock & Clock::operator ++ ()中的引用表示返回的是一個本類對象的引用，即返回的是一個左值。
為了更好地理解左值的概念，我們下面舉一個簡單的例子：
-
#include<iostream>
-
using
namespace
std;
-
-
class Test{
-
-
public:
-
//構造函數
-
Test(
int i =
0,
double j =
0.0) : m_i(i), m_j(j){
-
-
}
-
-
//賦值構造函數
-
Test
operator=(Test &rhs){
//返回引用
-
this->m_i = rhs.m_i;
-
this->m_j = rhs.m_j;
-
return *
this;
-
}
-
//Test operator=(Test &rhs){ //返回值
-
//this->m_i = rhs.m_i;
-
//this->m_j = rhs.m_j;
-
//return *this;}
-
-
int m_i;
-
double m_j;
-
};
-
-
-
int main(){
-
-
//1、賦初值，輸出 1 2.3
-
Test obj1(1, 2.3);
-
cout << obj1.m_i <<
endl << obj1.m_j <<
endl;
-
cout <<
endl <<
"-------------------" <<
endl;
-
-
//2、未賦初值，輸出0 0
-
Test obj2;
-
cout << obj2.m_i <<
endl << obj2.m_j <<
endl;
-
cout <<
endl <<
"-------------------" <<
endl;
-
-
//3、未賦初值，但是通過賦值構造函數進行了賦初值，但是注意是重復調用賦值構造函數賦初值。
-
Test obj3;
-
(obj3 = obj2 )= obj1;
//這里，先進行obj3 = obj2 的操作, (賦值成功后通過return *this，返回obj2對象), 然后進行 obj3 = obj1 的操作。
-
cout << obj3.m_i <<
endl << obj3.m_j <<
endl;
-
cout <<
endl <<
"-------------------" <<
endl;
-
-
system(
"pause");
-
return
0;
-
}
函數返回引用的運行結果如下：
函數返回值的運行結果如下：
從運行結果可以看出當返回值時，函數返回值時會產生一個臨時變量作為函數返回值的副本，並調用復制構造函數將*this傳給這個臨時變量，並且賦值得到的是一個右值，右值是不能繼續賦值的，而返回引用時，引用就是obj對象本身，賦值得到一個左值，是可以繼續賦值的，其原因是這是為了支持連續的=號操作，如：A a,b,c .調用(a=b)=c,這種情況下就要要求重載操作符=號必須返回一個*this的引用，這樣a=b才能得到一個更新后的a,再用c對其賦值才能作用到更新 的a身上，如果不返回*this的引用，將無法完成第二次用c的那個賦值。調用成員函數時*this指向該對象本身。
下面分類講述返回“值”和返回“引用”的不同點：
函數返回值時會產生一個臨時變量作為函數返回值的副本，而返回引用時不會產生值的副本。
T f(); 返回一般的類類型，返回的類類型不能作為左值，但返回的類類型可以直接調用成員函數來修改，如function().set_Value(); 返回類類型調用復制構造函數。
const T f(); 此種類型與上述第一種相同，唯一不同的是返回的類類型不能調用成員函數來修改，因為有const限定符。
T& f(); 返回類的引用可以作為左值，並且返回的類類型引用可以直接調用成員函數來修改，返回的類類型不會調用復制構造函數。
const T& f(); 不能作為左值，不能調用成員函數修改，不會調用復制構造函數。
轉載於:https://blog.csdn.net/zhuzhaoming1994/article/details/80371779