❶ c++重載運算符
C++中預定義的運算符其運算對象只能是基本數據類型，而不適用於用戶自定義類型（如類）.
// 同上，內置的運算符 只能應用於內置的數據類型 ...比如 int char double .等等。
(一) C++不允許用戶自己定義新的運算符，只能對已有的C++運算符進行重載。
// 就是說只能重載內置的 + - * / 等運算符，不能自己創造運算符計算。 。
（二） C++允許重載的運算符C++中絕大部分的運算符允許重載.
不能重載的運算符只有5個：
(1) 成員訪問運算符.
(2) 作用域運算符∷
(3) 條件運算符?:
(4) 成員指針運算符*
(5) 編譯預處理命令的開始符號#
(三) 重載不能改變運算符運算對象(即操作數)的個數。
// 不能改變運算符運算對象， 比如+法運算符，那麼它有兩個操作數 ..當我們重載它的時候 也只能有兩個操作數 。
(四) 重載不能改變運算符的優先順序別。
// 重載完之後並不能改變它的優先順序別，比如 +號， 無論你怎麼設計重載函數. 它永遠不可能比()的優先順序高......
(五) 重載運算符的函數不能有默認的參數，否則就改變了運算符參數的個數，與前面第(3)點矛盾。
// 於上面3..同。
(六) 重載的運算符必須和用戶定義的自定義類型的對象一起使用，其參數至少應有一個是類對象(或類對象的引用)。也就是說，參數不能全部是C++的標准類型，以防止用戶修改用於標准類型數據的運算符的性質。
// 重載的參數不能全部是C++內置數據類型。 至少要有一個是自定義類型。因為如果我們定義的是兩個內置的類型 就會跟系統所定義的沖突。 因為當我們使用內置的運算符時，那麼編譯器其實也是調用的一個重載運算符進行計算。這是編譯器自動添加的。 如果我們也定義的相同 那麼肯定會產生沖突。
(七) 用於類對象的運算符一般必須重載，但有兩個例外，運算符「=」和「&」不必用戶重載。
① 賦值運算符(=)可以用於每一個類對象，可以利用它在同類對象之間相互賦值。
② 地址運算符&也不必重載，它能返回類對象在內存中的起始地址。
// 前面已經說過，C++內置運算符只能計算內置的數據類型 。所以當我們要使用自定義類型時 就必須要進行重載..
總之，當C++語言原有的一個運算符被重載之後，它原先所具有的語義並沒有消失，只相當於針對一個特定的類定義了一個新的運算符。
運算符重載可以使用成員函數和友元函數兩種形式。可以參考以下的經驗：
(1)只能使用成員函數重載的運算符有：=、()、[]、->、new、delete。
(2)單目運算符最好重載為成員函數。
(3) 對於復合的賦值運算符如+=、-=、*=、/=、&=、!=、~=、%=、>>=、<<=建議重載為成員函數。
(4) 對於其它運算符，建議重載為友元函數。
運算符重載的方法是定義一個重載運算符的函數，在需要執行被重載的運算符時，系統就自動調用該函數，以實現相應的運算。也就是說，運算符重載是通過定義函數實現的。運算符重載實質上是函數的重載。重載運算符的函數一般格式如下：
函數類型 operator 運算符名稱 (形參表列)
{
對運算符的重載處理
}
重載為類成員函數時參數個數=原操作數個數-1
（後置++、--除外）
// 當重載為類成員函數時，參數個數等於原來的操作數-1 ..比如 對象a +對象b ..我們重載的時候需要兩個操作數 a 和b 但我們傳遞過去一個就可以了 ， 比如 a+b 我們只需要把b傳遞過去就可以了。因為當調用重載運算符時 就是a調用的重載運算符，那麼它就是當前對象 它就是這時的this 指針 ..而且類成員函數只能使用兩個類中成員...
重載為友元函數時 參數個數=原操作數個數，且至少應該有一個自定義類型的形參。
//與上面沒多大區別，但它卻可以調用非類中對象.. 比如調用一個對象a+1 ..注意的是即使定義為友元函數，它的操作數也必須有一個為自定義類型。
看一個實例：
#include<iostream>
using namespace std;
class complex //復數類聲明
{
public: //外部介面
complex(double r=0.0,double i=0.0)
{
real=r;
imag=i;
} //構造函數
complex operator + (complex c2); //+重載為成員函數
complex operator - (complex c2); //-重載為成員函數
void display(); //輸出顯示復數
private: //私有數據成員
double real; //復數實部
double imag; //復數虛部
};
complex complex::operator +(complex c2) //重載函數實現
{
complex c;
c.real=real+c2.real;
c.imag=imag+c2.imag;
return complex(c.real,c.imag);
}
complex complex::operator -(complex c2) //重載函數實現
{
complex c;
c.real=real-c2.real;
c.imag=imag-c2.imag;
return complex(c.real,c.imag);
}
void complex::display()
{ cout<<"("<<real<<","<<imag<<"i"<<")"<<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();
system("pause");
return 0;
}
程序輸出的結果為：
c1=(5,4i)
c2=(2,10i)
c3=c1-c2=(3,-6i)
c3=c1+c2=(7,14i)
通過代碼我們可以看出： 定義了兩個成員函數重載運算符..重載了+ 和- . 當我們使用這個類的兩個成員進行相加的或者相減的時候就會自動調用重載的運算符..使用我們在重載的運算符中所定義的操作。那我們可以看到，在進行+或者-的時候是把兩個對象中保存的復數的值進行加減 然後返回了。 要注意的是並不是+號和減號被完全改變了，而只是這個類中的對象在進行+ -操作的時候才會調用重載.
我們來測試一下; 我們在main()函數中再定義三個變數 ，int a=5,b=3,c; c=a-b ; 然後再輸出c的值 ，我們發現輸出為2 . .這也證明了我們所定義的重載運算符並沒有改變它原來的功能..而是賦予了它多重的含義..
那我們再來看下運算符重載在友元函數中的使用。
我們只需要將complex complex::operator +(complex c2) //重載函數實現
{
complex c;
c.real=real+c2.real; // real 代表 this->real 其實就是代表傳遞進來的當前對象.
c.imag=imag+c2.imag;
return complex(c.real,c.imag);
}
這段代碼 修改一下... 改為 complex friend complex::operator +(complex c2 complex c3)
那麼同樣也可以完成相同的功能..而且還更容易擴充..因為從上面得知..重載的運算符必須和用戶定義的自定義類型的對象一起使用. 也就是說至少有一個自定義類型..或者是它的引用..如果我們使用成員運算符重載的話只能使用類中的對象成員..而使用友元運算符重載那麼我們則可以使用類外的數據..當我們需要使用的時候直接修改為 complex friend complex::operator +(complex c2 int a) 如這樣的形式就可以了。
❷ 關於C++重載運算符
所謂重載，就是重新賦予新的含義。函數重載就是對一個已有的函數賦予新的含義，使之實現新功能。
運算符也可以重載
運算符重載是對已有的運算符賦予多重含義
必要性
C++中預定義的運算符其運算對象只能是基本數據類型，而不適用於用戶自定義類型（如類）
(一) C++不允許用戶自己定義新的運算符，只能對已有的C++運算符進行重載。
（二） C++允許重載的運算符C++中絕大部分的運算符允許重載.
不能重載的運算符只有5個：
(1) 成員訪問運算符.
(2) 作用域運算符∷
(3) 條件運算符?:
(4) 成員指針運算符*
(5) 編譯預處理命令的開始符號#
(三) 重載不能改變運算符運算對象(即操作數)的個數。
(四) 重載不能改變運算符的優先順序別。
(五) 重載運算符的函數不能有默認的參數，否則就改變了運算符參數的個數，與前面第(3)點矛盾。
(六) 重載的運算符必須和用戶定義的自定義類型的對象一起使用，其參數至少應有一個是類對象(或類對象的引用)。也就是說，參數不能全部是C++的標准類型，以防止用戶修改用於標准類型數據的運算符的性質。
(七) 用於類對象的運算符一般必須重載，但有兩個例外，運算符「=」和「&」不必用戶重載。
① 賦值運算符(=)可以用於每一個類對象，可以利用它在同類對象之間相互賦值。
② 地址運算符&也不必重載，它能返回類對象在內存中的起始地址。
總之，當C++語言原有的一個運算符被重載之後，它原先所具有的語義並沒有消失，只相當於針對一個特定的類定義了一個新的運算符。
運算符重載可以使用成員函數和友元函數兩種形式。可以參考以下的經驗：
(1)只能使用成員函數重載的運算符有：=、()、[]、->、new、delete。
(2)單目運算符最好重載為成員函數。
(3) 對於復合的賦值運算符如+=、-=、*=、/=、&=、!=、~=、%=、>>=、<<=建議重載為成員函數。
(4) 對於其它運算符，建議重載為友元函數。
運算符重載的方法是定義一個重載運算符的函數，在需要執行被重載的運算符時，系統就自動調用該函數，以實現相應的運算。也就是說，運算符重載是通過定義函數實現的。運算符重載實質上是函數的重載。重載運算符的函數一般格式如下：
函數類型 operator 運算符名稱 (形參表列)
{
對運算符的重載處理
}
重載為類成員函數時參數個數=原操作數個數-1
（後置++、--除外）
重載為友元函數時 參數個數=原操作數個數，且至少應該有一個自定義類型的形參。
將「+」、「-」運算重載為復數類的成員函數。
規則:
實部和虛部分別相加減。
操作數:
兩個操作數都是復數類的對象。
#include<iostream>
using namespace std;
class complex //復數類聲明
{
public: //外部介面
complex(double r=0.0,double i=0.0)
{
real=r;
imag=i;
} //構造函數
complex operator + (complex c2); //+重載為成員函數
complex operator - (complex c2); //-重載為成員函數
void display(); //輸出顯示復數
private: //私有數據成員
double real; //復數實部
double imag; //復數虛部
};
complex complex::operator +(complex c2) //重載函數實現
{
complex c;
c.real=real+c2.real;
c.imag=imag+c2.imag;
return complex(c.real,c.imag);
}
complex complex::operator -(complex c2) //重載函數實現
{
complex c;
c.real=real-c2.real;
c.imag=imag-c2.imag;
return complex(c.real,c.imag);
}
void complex::display()
{ cout<<"("<<real<<","<<imag<<「i」<<")"<<endl; }
void 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();
}
程序輸出的結果為：
c1=(5,4i)
c2=(2,10i)
c3=c1-c2=(3,-6i)
c3=c1+c2=(7,14i)
在本程序中對運算符「+」,」-」進行了重載，使之能用於兩個復數的相加減。在該例中運算符重載函數operator+ ，operator－作為Complex類中的成員函數。
「+」 ，」-」是雙目運算符，為什麼在程序中的重載函數中只有一個參數呢？實際上，運算符重載函數有兩個參數，由於重載函數是Complex類中的成員函數，有一個參數是隱含的，運算符函數是用this指針隱式地訪問類對象的成員。
可以看到，重載函數operator+訪問了兩個對象中的成員，一個是this指針指向的對象中的成員，一個是形參對象中的成員。如this->real+c2.real，this->real就是c1.real。
在將運算符函數重載為成員函數後，如果出現含該運算符的表達式，如c1+c2,編譯系統把它解釋為c1.operator+(c2)
即通過對象c1調用運算符重載函數，並以表達式中第二個參數(運算符右側的類對象c2)作為函數實參。運算符重載函數的返回值是Complex類型，返回值是復數c1和c2之和(Complex(c1.real + c2.real,c1.imag+c2.imag))。
仔細看下吧 你的問題都在裡面 這是我們的PPT
❸ C++中的運算符重載，幫我詳細介紹下
運算符重載是對已有的運算符賦予多重含義，使同一個運算符作用於不同類型的數據導致不同類型的行為。運算符重載的實質就是函數重載。在實現過程中，首先把指定的運算表達式轉化為對運算符函數的調用，運算對象轉化為運算符函數的實參，然後根據實參的類型來確定需要調用的函數，這個過程是在編譯過程中完成的。
一、運算符重載的作用
運算符重載為類的用戶提供了更直觀的介面，使類類型的對象也可以像普通變數一樣進行運算符的表達式運算。運算符重載允許C/C++的運算符在用戶定義類型(類)上擁有一個用戶定義的意義。
二、運算符重載的規則
（1）C++中的運算符除了少數幾個以外，全部可以重載，而且只能重載已有的運算符。
可以重載的運算符有：
算術運算符：+,-,*,/,%,++,--;
位操作運算符：&,|,~,^,＜＜,＞＞
邏輯運算符：!,&&,||;
比較運算符：＜,＞,＞=,＜=,==,!=;
賦值運算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;
其他運算符：[],(),-＞,,(逗號運算符),new,delete,new[],delete[],-＞*。
不能重載的運算符只有5個：
類屬關系運算符「.」，成員指針運算符「*」，作用域分辨符「::」，sizeof運算符和三目運算符「?:」。
（2）重載之後運算符的優先順序和結合性都不變。
（3）四個「不能改變」
·不能改變運算符操作數的個數；
·不能改變運算符原有的優先順序；
·不能改變運算符原有的結合性；
·不能改變運算符原有的語法結構。
（4）至少要有一個操作對象是自定義類型。
（5）重載的運算符含義必須清楚，不能有二義性。
三、運算符重載的2種方法
（1）運算符重載為成員函數
（a）對於雙目運算符op，如果要重載op為某類的成員函數，使之能夠實現表達式 k op t，其中k為A類的對象，則應當把op重載為A類的成員函數，該函數只有一個形參，形參的類型是t所屬的類型。經過這樣重載之後，表達式 k op t 就相當於函數調用k.operator op( t )
（b）對於前置單目運算符U(如負號「-」)，若要重載U為類的成員函數，用來實現表達式
U oprd，其中oprd為A類的對象，則U應當重載為A類的成員函數，且該函數不帶形參。經過重載之後，表達式U oprd 就相當於函數調用oprd.operator U()。
（b）後置運算符「++」和「--」，若要將它們重載為類的成員函數，用來實現表達式oprd++或oprd--，其中oprd為A類的對象，那麼就應當重載這2個運算符為A類的成員函數，這時函數要帶有一個整型（int）形參。重載之後，表達式 oprd ++ 和 oprd -- 就分別相當於函數調用oprd.operator ++(0) 和 oprd.operator --(0)。
（2）運算符重載為友元函數
（a）對於雙目運算符op，如果它的一個操作數為類A的對象，就可以將op重載為A類的友元函數，該函數有兩個形參，其中一個形參的類型是A類。經過這樣的重載之後，表達式k op t就相當於函數調用operator op( k, t )
（b）對於前置單目運算符U(如負號「-」)，若要實現表達式 U oprd 其中oprd為A類的對象，則U可以重載為A類的友元函數，函數的形參為A類的對象oprd。經過重載之後，表達式
U oprd 就相當於函數調用operator U( oprd )
(c)對於後置運算符「++」和「--」，如果要實現表達式 oprd ++ 或 oprd --, 其中oprd為A類的對象，那麼運算符就可以重載為A類的友元函數，這時函數的形參有兩個，一個是A類的對象oprd，另一個是整型（int）形參。第二個參數是用於與前置運算符函數相區別的。重載之後，表達式oprd ++ 和 oprd -- 就分別相當於函數調用operator ++ (oprd, 0)
和operator -- (oprd, 0)。
❹ 操作符的重載方法
//使用成員函數重載運算符
#include <iostream>
using namespace std;
class example
{
private:
int val;
public:
example(int v = 0) { val = v; }
void setval(int v) { val = v; }
int getval() { return val; }
example operator +(example);
};
//成員函數重載運算符只需要一個參數，執行時由表達式左邊的對象調用函數
example example::operator +(example o)
{
example t(val + o.val);
return t;
}
int main()
{
example ex1(3), ex2, ex3;
ex2.setval(5);
ex3 = ex1 + ex2; //由ex1調用函數
cout << ex3.getval() << endl;
return 0;
}
//使用友元函數重載運算符，主函數同上
class example
{
private:
int val;
public:
example(int v = 0) { val = v; }
void setval(int v) { val = v; }
int getval() { return val; }
friend example operator +(example, example);
};
//友元函數重載運算符需要兩個參數，可以直接訪問類的私有數據成員
example operator +(example o1, example o2)
{
example t(o1.val + o2.val);
return t;
}
//使用普通函數重載運算符，主函數同上
class example
{
private:
int val;
public:
example(int v = 0) { val = v; }
void setval(int v) { val = v; }
int getval() { return val; }
};
//普通函數重載運算符需要兩個參數，不能直接訪問類的私有數據成員
example operator +(example o1, example o2)
{
example t(o1.getval() + o2.getval());
return t;
}
❺ 運算符重載的方法,運算符重載函數有哪幾類,常用的是那兩類
運算符重載函數有成員函數和友元函數兩類。
有些運算符隨便用二者之一實現重載，例如+
有些運算符只能用友元函數重載，例如<<
有些運算符只能用成員函數重載，例如=
❻ C++中如何重載整型運算符
//嘗試下面這種重載運算符的方法：
#include<iostream>
usingnamespacestd;
classPower{
public:
Power(intx){
oper_num=x;
}
friendintoperator^(Power&x,Power&y);//重載運算符作為友元函數
private:
intoper_num;
};
intoperator^(Power&x,Power&y){
if(y.oper_num==0)return1;
if(y.oper_num==1)returnx.oper_num;
return(int)pow(double(x.oper_num),double(y.oper_num));
}
intmain()
{
Powerx(4),y(2);
intresult=x^y;
cout<<result<<endl;
return0;
}
❼ Python正確重載運算符的方法示例詳解
Python正確重載運算符的方法示例詳解
說到運算符重載相信大家都不陌生，運算符重載的作用是讓用戶定義的對象使用中綴運算符（如 + 和 |）或一元運算符（如 - 和 ~）。說得寬泛一些，在 Python 中，函數調用（()）、屬性訪問（.）和元素訪問 / 切片（[]）也是運算符。
我們為 Vector 類簡略實現了幾個運算符。__add__ 和 __mul__ 方法是為了展示如何使用特殊方法重載運算符，不過有些小問題被我們忽視了。此外，我們定義的Vector2d.__eq__ 方法認為 Vector(3, 4) == [3, 4] 是真的（True），這可能並不合理。下面來一起看看詳細的介紹吧。
運算符重載基礎
在某些圈子中，運算符重載的名聲並不好。這個語言特性可能（已經）被濫用，讓程序員困惑，導致缺陷和意料之外的性能瓶頸。但是，如果使用得當，API 會變得好用，代碼會變得易於閱讀。Python 施加了一些限制，做好了靈活性、可用性和安全性方面的平衡：
不能重載內置類型的運算符
不能新建運算符，只能重載現有的
某些運算符不能重載——is、and、or 和 not（不過位運算符
&、| 和 ~ 可以）
前面的博文已經為 Vector 定義了一個中綴運算符，即 ==，這個運算符由__eq__ 方法支持。我們將改進 __eq__ 方法的實現，更好地處理不是Vector 實例的操作數。然而，在運算符重載方面，眾多比較運算符（==、!=、>、<、>=、<=）是特例，因此我們首先將在 Vector 中重載四個算術運算符：一元運算符 - 和 +，以及中綴運算符 + 和 *。
一元運算符
-（__neg__）
一元取負算術運算符。如果 x 是 -2，那麼 -x == 2。
+（__pos__）
一元取正算術運算符。通常，x == +x，但也有一些例外。如果好奇，請閱讀「x 和 +x 何時不相等」附註欄。
~（__invert__）
對整數按位取反，定義為 ~x == -(x+1)。如果 x 是 2，那麼 ~x== -3。
支持一元運算符很簡單，只需實現相應的特殊方法。這些特殊方法只有一個參數，self。然後，使用符合所在類的邏輯實現。不過，要遵守運算符的一個基本規則：始終返回一個新對象。也就是說，不能修改self，要創建並返回合適類型的新實例。
對 - 和 + 來說，結果可能是與 self 同屬一類的實例。多數時候，+ 最好返回 self 的副本。abs(...) 的結果應該是一個標量。但是對 ~ 來說，很難說什麼結果是合理的，因為可能不是處理整數的位，例如在ORM 中，SQL WHERE 子句應該返回反集。
def __abs__(self):
return math.sqrt(sum(x * x for x in self))
def __neg__(self):
return Vector(-x for x in self) #為了計算 -v，構建一個新 Vector 實例，把 self 的每個分量都取反
def __pos__(self):
return Vector(self) #為了計算 +v，構建一個新 Vector 實例，傳入 self 的各個分量
x 和 +x 何時不相等
每個人都覺得 x == +x，而且在 Python 中，幾乎所有情況下都是這樣。但是，我在標准庫中找到兩例 x != +x 的情況。
第一例與 decimal.Decimal 類有關。如果 x 是 Decimal 實例，在算術運算的上下文中創建，然後在不同的上下文中計算 +x，那麼 x!= +x。例如，x 所在的上下文使用某個精度，而計算 +x 時，精度變了，例如下面的
❽ 運算符重載的方法
struct A
{
int a,b;
};
ostream &operator << (ostream &o,const A&aa)
{
o<<aa.a<<'\t'<<aa.b<<endl;
}
A &operator++(A &aa)
{
++aa.a,++aa.b;
return aa;
}
int main()
{
A a={1,2};
cout<<++a<<endl;
return 0;
}
這個只是一個最簡單的重載的舉例。。
❾ 如何重載運算符
我沒編譯。但是問題在於。你+=的是int。 int 對double, complex 都存在轉換。它沒法決定轉換成哪個。所以你的main()中1改成1.0吧~
也可以為int再重載一遍。
❿ 如何實現函數運算符重載
3.運算符重載稱動態多態性，他是通過繼承和虛函數實現的。
運算符重載通過創建運算符函數operator@()來實現。運算符函數定義了重載的運算符將要進行的操作，這種操作通常作用在一個類上。這樣，在編譯時遇到名為operator@的運算符函數（@表示所要重載的運算符），就檢查傳遞給函數的參數的類型。
重載運算符與預定義運算符的使用方法完全相同，它不能改變原有運算符的參數個數（單目或雙目），也不能改變原有的優先順序的結合性。用戶不能定義新的運算符，只能從C++已有的運算符中選擇一個恰當的運算符重載。
3.1成員運算符函數
運算符函數可以定義為它將要操作的類的成員（稱為成員運算符函數），也可以定義為非類的成員，但是非成員的運算符函數大多是類的友元函數（稱為友元運算符函數）。
成員運算符函數在類中的聲明格式為：
class X{
//……
type operator@(參數表)；
}；
其中type為函數的返回類型，@為所要重載的運算符符號，X是重載此運算符的類名，參數表中羅列的是該運算符所需要的操作數。
成員運算符函數定義的形式一般為：
type X::operator@(參數表)
//函數體}
其符號的含義與聲明時相同。
在成員運算符函數的參數表中，若運算符是單目的，則參數表為空，此時當前對象作為運算符的一個操作數，通過this指針隱含地傳遞給函數的；若運算符是雙目的，則參數表中有一個操作數，它作為運算符的右操作參數，此時當前對象做為運算符的左操作數，它是this指針隱含地傳遞給函數的。總之成員運算符函數operator@所需要的一個操作數是由對象通過this指針隱含傳遞。