C++哪些運算符重載能夠重載？

阿新 • • 發佈：2017-08-15

使用 sizeof 全部作用域 unsigned 必須 ng- pen error

運算符重載是C++極為重要的語言特性之中的一個。本文將用代碼實例回答——C++哪些運算符能夠重載？怎樣重載？實現運算符重載時須要註意哪些？

哪些運算符能夠重載，哪些不可重載？

C++98，C++0x，C++11對“哪些運算符重載能夠重載”有一致的規定。詳細例如以下：

技術分享

當中，非常少使用的是“,”（逗號運算符）。

標準相同規定了不可重載的運算符：

技術分享

當中，“::”是作用域運算符。

“?:”是條件運算符。

兩個較少使用的運算符是 .* 和 ->* 各自是：

.* 對象調用成員函數指針；

->* 對象指針調用成員函數指針。

標準還指出，有的運算符能夠同一時候支持“一元運算”和“二元運算”：

技術分享

下文通過實現幾個模擬內置類型的類來展示詳細的運算符重載方法應當怎樣實現。

一些註意事項

實現運算符重載時應註意：

運算符重載不改變運算符的優先級與結合性，如/的優先級比-高;
運算符重載不改變部分運算符對操作數個數的限制，如+僅僅能有兩個操作數;

模擬整型Integer

回憶一下C++裏整型支持支持那些運算？詳細有：

算術運算：

正。如 +a；負，如 -a；

加，如 a + b；減，如 a - b；乘。如 a * b；除。如 a / b。取余（模），如 a % b；

自增自減（整型特有）：

自增，如 a++，++a；自減，如 a--，--a；

比較運算：

大於，如 a > b；小於，如 a < b；

等於。如 a == b。不等於，如 a != b。

大於等於。如 a >= b。小於等於。如 a <= b。

位運算：

按位取反。如 ~a。

左移，如 a << 2。右移，如 a >> 3；

按位與，如 a & b。按位或，如 a | b；按位異或，如 a ^ b；

賦值運算：

賦值。a = 5；

復合賦值：

+=。-=，*=，/=，%=，（算數運算與賦值運算復合）

&=。|=，^=，<<=，>>=。（位運算與賦值運算復合）

以下是這個Integer的代碼：

class Integer
{
public:
	Integer(int ival) : value(ival) {}
	Integer(const Integer& iobj) : value(iobj.value) {}
	
	// operator int() { return value; } // conversion to built-in int

	Integer operator+() const { return Integer(value); }
	Integer operator-() const { return Integer(-value); }
	
	Integer operator+(const Integer& rhs) const { return Integer(value + rhs.value); }
	Integer operator-(const Integer& rhs) const { return Integer(value - rhs.value); }
	Integer operator*(const Integer& rhs) const { return Integer(value * rhs.value); }
	Integer operator/(const Integer& rhs) const { return Integer(value / rhs.value); }
	Integer operator%(const Integer& rhs) const { return Integer(value % rhs.value); }
	
	// prefix
	Integer operator++() { return Integer(++value); }
	Integer operator--() { return Integer(--value); }
	
	// suffix
	Integer operator++(int) { int old = value; value++; return Integer(old); }
	Integer operator--(int) { int old = value; value--; return Integer(old); }

	// compare:
	bool operator<(const Integer& rhs) const { return value < rhs.value; }
	bool operator>(const Integer& rhs) const { return value > rhs.value; }
	bool operator==(const Integer& rhs) const { return value == rhs.value; }
	bool operator!=(const Integer& rhs) const { return value != rhs.value; }
	bool operator<=(const Integer& rhs) const { return value <= rhs.value; }
	bool operator>=(const Integer& rhs) const { return value >= rhs.value; }
	
	// bit operations:
	Integer operator~() const { return Integer(~value); }
	Integer operator<<(unsigned n) const { return Integer(value << n); }
	Integer operator>>(unsigned n) const { return Integer(value >> n); }
	Integer operator&(const Integer& rhs) const { return Integer(value & rhs.value); }
	Integer operator|(const Integer& rhs) const { return Integer(value | rhs.value); }
	Integer operator^(const Integer& rhs) const { return Integer(value ^ rhs.value); }

	// assignment:
	Integer operator=(const Integer& rhs) { return value = rhs.value; }
	// compound assignment:
	Integer operator+=(const Integer& rhs) { return value += rhs.value; }
	Integer operator-=(const Integer& rhs) { return value -= rhs.value; }
	Integer operator*=(const Integer& rhs) { return value *= rhs.value; }
	Integer operator/=(const Integer& rhs) { return value /= rhs.value; }
	Integer operator%=(const Integer& rhs) { return value %= rhs.value; }
	Integer operator&=(const Integer& rhs) { return value &= rhs.value; }
	Integer operator|=(const Integer& rhs) { return value |= rhs.value; }
	Integer operator^=(const Integer& rhs) { return value ^= rhs.value; }
	Integer operator<<=(const Integer& rhs) { return value <<= rhs.value; }
	Integer operator>>=(const Integer& rhs) { return value >>= rhs.value; }
// private:
	int value;
};

實現運算符重載函數時。須要註意的是末尾是否要加const？
這取決與操作是否會改變當前對象的成員值。假設不改變則不加，改變則加。

Integer類僅僅是為了展示怎樣使用運算符重載，並沒有多少有用價值。

一下是Integer類的測試：

void testInteger()
{
	Integer i = 123;

#define SEPRATER ":\t"
#define TRACE_INTEGER(iobj) printf(#iobj SEPRATER "%d\n", (iobj).value) 
#define TRACE_BOOL(exp) printf(#exp SEPRATER "%s\n", (exp) ? "true" : "false")
#define TRACE_HEX(iobj) printf(#iobj SEPRATER "%p\n", (iobj).value)

	TRACE_INTEGER(i);
	TRACE_INTEGER(+i);
	TRACE_INTEGER(-i);
	
	Integer j = 5;
	TRACE_INTEGER(i+j);
	TRACE_INTEGER(i-j);
	TRACE_INTEGER(i*j);
	TRACE_INTEGER(i/j);
	TRACE_INTEGER(i%j);
	
	TRACE_INTEGER(++i); TRACE_INTEGER(i);
	TRACE_INTEGER(--i); TRACE_INTEGER(i);
	TRACE_INTEGER(i++); TRACE_INTEGER(i);
	TRACE_INTEGER(i--); TRACE_INTEGER(i);
	
	TRACE_BOOL(i>j);
	TRACE_BOOL(i<j);
	TRACE_BOOL(i==j);
	TRACE_BOOL(i!=j);
	TRACE_BOOL(i>=j);
	TRACE_BOOL(i<=j);
	
	TRACE_HEX(i);
	TRACE_HEX(~i);
	TRACE_HEX(i<<4);
	TRACE_HEX(i>>4);
	TRACE_HEX(i<<24);
	
	TRACE_HEX(i & ~0xF); // i & ~0xF <<== same as ==>> i & Integer(~0xF), because C++ implicit conversion.
	TRACE_HEX(i | 0xF0);
	TRACE_HEX(i ^ 0xF0);
	
	TRACE_INTEGER(i);
	TRACE_INTEGER(j);
	TRACE_INTEGER(i=j);
	
	TRACE_INTEGER(i+=j);
	TRACE_INTEGER(i-=j);
	TRACE_INTEGER(i*=j);
	TRACE_INTEGER(i/=j);
	
	j = 3;
	TRACE_INTEGER(i%=j);
}

該測試的輸出例如以下：

i:	123
+i:	123
-i:	-123
i+j:	128
i-j:	118
i*j:	615
i/j:	24
i % :	3
++i:	124
i:	124
--i:	123
i:	123
i++:	123
i:	124
i--:	124
i:	123
i>j:	true
i<j:	false
i==j:	false
i!=j:	true
i>=j:	true
i<=j:	false
i:	0000007B
~i:	FFFFFF84
i<<4:	000007B0
i>>4:	00000007
i<<24:	7B000000
i & ~0xF:	00000070
i | 0xF0:	000000FB
i ^ 0xF0:	0000008B
i:	123
j:	5
i=j:	5
i+=j:	10
i-=j:	5
i*=j:	25
i/=j:	5
i%=j:	2

模擬指針Pointer

再回憶一下原生的指針支持那些運算？

詳細有：

*，解引用。從T*得到T

[]，下標運算

++，自增

--，自減

+，加法

-，減法

有一點值得註意的是：

每種類型都相應一種指針，如int相應int*；
解引用和下標運算的返回結果能夠做“左值”（賦值運算符左邊的值。即能夠賦值）。
指針的加減，-是以指針當前類型的大小為單位的。即：若有指針p，則 (size_t)(p + 1) == (size_t)p + sizeof(*p)

要實現1，Pointer類型必須實現為類模板；

Pointer實現為類模板，它的數據成員（data member）就能夠是原生指針，能夠非常自然的支持原生指針的加減運算。

據此實現的Pointer類例如以下：

template <typename T>
class Pointer 
{
public:
	Pointer() : ptr_(0) {}
	Pointer(T* ptr) : ptr_(ptr) {}
	
	// operator T*() { return ptr_; } // implicit conversion.
	T* get() const { return ptr_; }	
	
	T& operator*() const { return *ptr_; }
	T* operator->() const { return ptr_; printf("operator->()\n"); }
	T& operator[](int offset) const { return ptr_[offset]; }
	
	Pointer<T> operator++() { return Pointer(++ptr_); } // prefix
	Pointer<T> operator--() { return Pointer(--ptr_); } // prefix
	
	Pointer<T> operator++(int) { return Pointer(ptr_++); } // suffix
	Pointer<T> operator--(int) { return Pointer(ptr_--); } // suffix
	
	Pointer<T> operator+=(int off) { return Pointer(ptr_ += off); }
	Pointer<T> operator-=(int off) { return Pointer(ptr_ -= off); }
	
	Pointer<T> operator+(int off) const { return Pointer(ptr_ + off); }
	Pointer<T> operator-(int off) const { return Pointer(ptr_ - off); }
// private:
	T* ptr_;
};

Pointer類僅模擬指針的一般運算，並沒有考慮“通過指針進行資源管理”這一主題，全部也沒有保證delete ptr的實際行為。

下面是該類的測試程序：

template<typename T>
ostream& operator<<(ostream& out, const Pointer<T>& ptr)
{
	out << ptr.ptr_;
	return out;	
}

//#define TRACE(fmt, exp) printf(#exp ":\t" fmt, (exp))
#define TRACE(exp) cout << #exp << ":\t" << (exp) << endl
#define ARRAY_SIZE(a) sizeof(a)/sizeof(a[0])

int ia[] = { 123, 456, 789, 111, 222, 333 };

void testPointer()
{
	for(int i=0; i<ARRAY_SIZE(ia); ++i) {
		printf("%p: %d\n", &ia[i], ia[i]);
	}

	Pointer<int> ptr = &ia[0];
	
	TRACE(ptr);
	TRACE(ia);
	TRACE(*ptr);
	TRACE(ptr[1]);
	
	TRACE(++ptr); TRACE(*ptr);
	TRACE(--ptr); TRACE(*ptr);
	
	TRACE(ptr++); TRACE(*ptr);
	TRACE(ptr--); TRACE(*ptr);
	
	TRACE(ptr+=2); TRACE(*ptr);
	TRACE(ptr-=2); TRACE(*ptr);
	
	ptr = &ia[3];
	TRACE(ptr+2); TRACE(*(ptr+2));
	TRACE(ptr-2); TRACE(*(ptr-2));
	
	ptr[0] = 555;
	TRACE(ptr[0]);
	
	*ptr = 666;
	TRACE(*ptr);
}

測試程序的輸出例如以下：

0x603090: 123
0x603094: 456
0x603098: 789
0x60309c: 111
0x6030a0: 222
0x6030a4: 333
ptr:	0x603090
ia:	0x603090
*ptr:	123
ptr[1]:	456
++ptr:	0x603094
*ptr:	456
--ptr:	0x603090
*ptr:	123
ptr++:	0x603090
*ptr:	456
ptr--:	0x603094
*ptr:	123
ptr+=2:	0x603098
*ptr:	789
ptr-=2:	0x603090
*ptr:	123
ptr+2:	0x6030a4
*(ptr+2):	333
ptr-2:	0x603094
*(ptr-2):	456
ptr[0]:	555
*ptr:	666

以上測試testPointer並沒實用到operator->，以下單獨測試operator->：

struct Foo 
{
	int id;
	static int count;
	
	Foo() : id(++count) { printf("Foo::Foo(%p)\n", this); }
	~Foo() { printf("Foo::~Foo(%p)\n", this); }
	
	void show() { printf("Foo.show(%p): %d\n", this, id); }
};

int Foo::count = 0;

void testAccess()
{
	printf("\n%s():\n", __FUNCTION__);
	Pointer<Foo> fptr = new Foo();
	
	// test operator->
	fptr->show();     // access member function.
	TRACE(fptr->id);  // access data member.
	
	delete fptr.get();
}

該測試程序的輸出為：

testAccess():
Foo::Foo(0x133a010)
Foo.show(0x133a010): 1
fptr->id:	1
Foo::~Foo(0x133a010)

幾種特殊運算符的重載

上面的兩個類基本已經覆蓋了大部分的運算符重載，以下展示幾個“罕見”的運算符重載：

#define TRACE_CALL puts(__FUNCTION__)
class Operand
{
public:
	void operator,(const Operand& rhs) const { TRACE_CALL; }
	void operator,(int a) const { TRACE_CALL; }
	// void operator,(int a, int b) const { TRACE_CALL; } // ERROR: operator, 有且僅有一個參數
	void operator->*(int a) const { printf("%s(%d)\n", __FUNCTION__, a); }
};

測試程序：

void testOperand()
{
	Operand op1, op2;

	op1, op2;  // operator,
	op1->*123; // operator->*
}

程序輸出：

operator,
operator->*(123)

operator new與operator delete

關於operator new和operator delete的重載，下次另外寫博客闡釋。

C++哪些運算符重載能夠重載？

使用 sizeof 全部作用域 unsigned 必須 ng- pen error 運算符重載是C++極為重要的語言特性之中的一個。本文將用代碼實例回答——C++哪些運算符能夠重載？怎樣重載？實現運算符重載時須要註意哪些？

C++之運算符重載

cells pro 運算符重載似的 width uri erl wrap height C++ Code 1234567891011121314151617181920212223242526272829303132333435363738394041424

深入C++的運算符重載

stream pre 比較 float 聲明變量友元輸出賦值 per 對於簡單的運算符，可以參考之前的博文。之後會有一篇關於從等號運算符重載的角度研究深淺拷貝的博文。逗號運算符重載逗號運算符重載需要一個參數，並且返回自身類。逗號運算符在復制操作中比較常見，下

C++對運算符進行重載學習筆記

自定義類 hide main 臨時有一個 ostream oid pri 形參 1. 一個類的成員函數是暗含著 this 指針的，eg; 1 #include<iostream> 2 using namespace std; 3 4 class

c語言運算符優先級 ., *, (), []

元素 mas mask != 運算符 == int val c語言 .的優先級高於* []優先級高於*, int *ap[]等價於int *(ap[]), ap是元素為int指針的數組函數()高於*, int *fp()等價於int*(fp()), fp是函數，函數的返回

C 語言運算符優先級

運算 nbsp style lac 位或成員 == idt 按位異或每當想找哪個運算符優先級高時，很多時候總是想找的就沒有，真讓人氣憤！現在，終於有個我個人覺得非常全的，分享給大家，歡迎拍磚！ C語言運算符優先級優先級運算符名稱或含義

C#中==運算符

c#==運算符與基元類型　　我們分別用兩種方式比較兩個整數，第一個使用的是Equals(int)方法，每二個使用的是==運算符：　　 1 class Program 2 { 3 static void Main(String[] args) 4 { 5 int num1 = 5

C 語言運算符優先級（記憶口訣）

rowspan 異或運算符 new 取反 ica track -m trac 優先級運算符名稱或含義使用形式結合方向說明 1 [

C語言運算符優先級

邏輯與 [] 常量表達式 border colspan 自增運算符 eof 三目運算符長度 C語言運算符優先級優先級運算符名稱或含義使用形式結合方向說明 1 [] 數組下標數組名[常

c語言——運算符、分支結構、循環結構

amp stdio.h main 邏輯運算運算符 || urn cnblogs tab 一、運算符關系運算符關系運算符含義數學中的表示 < 小於 < <= 小於或等於 ≤ > 大於 > >= 大於或等於 ≥

C語言運算符優先級說明

pad 余數等於 span new strong lan clas spa 說明：參考http://www.jb51.net/article/37282.htm 優先級運算符名稱或含義使用形式

c#和c++的運算符優先級

clas 抽象 code lin style spa 優先 color nbsp 閑來無聊亂寫代碼。發現基礎的東西有的時候也非常的抽象。不信？那來看看下面這條語句： int i = 5; int j = 10; j = i = -i++; 如果上述代碼是vc++代

C語言運算符 / 和%的一些註意事項

左右 color 註意事項 cnblogs 計算 print result 使用 5.0 1.double無法使用取余符號%，浮點數無法取余，如170%30.48或170.8%7無法計算如果要計算，(1)乘以相應的倍數轉成整形，取余，再除以相應的倍數，轉為double型

c++位運算符介紹

邏輯或進行 order 存儲 cap exp 優先 example 右移下面是C/C++位操作運算符列表，其中運算符優先級為從上到下遞減，但<<，>>優先級相同。 C/C++位操作運算符操作符功能用法 ~ 位求反 ~expr

C#中運算符的優先級

tab 優先 nbsp 長度 str span 變量指針條件運算運算符名稱或含義使用形式結合方向說明 1 [ ] 數組下標數組名[整型表達式] 左到右　 ( ) 圓括號（表達式）/函

C++ 7 運算符

-- ++ 邏輯或關系運算符邏輯運算符 class 關系運算相等運算運算符：執行特定數學或邏輯操作的符號算術運算符 + - * / % ++ -- 關系運算符 == != > < >= <= 邏輯運算符 &&

記憶C語言運算符(文末福利)

C語言編程語言點擊上方“異步社區”，選擇“置頂公眾號”技術幹貨，第一時間送達學習第一門編程語言的時候，你很可能是讀過一本書，輸入了你不太懂的代碼，然後試圖弄懂它們的原理。我寫的其他書大多是這個樣子，這對初學者非常有效。初學的時候，對於有一些復雜的主題，你需要在弄懂它們之前先學會怎麽用，因此這是一個

C語言運算符優先級別表

pan 對象指針自增 mil 左移 sizeof wid 等於按位或優先級運算符名稱或含義使用形式結合方向說明 1 [] 數組下標數組名[常量

C語言“%”運算符

特殊情況 result ava 情況轉換兩個不能運算符特殊 C語言中運算符“%”是取余運算符，而非取模運算符。（運算符“%”在C/C++, JAVA中，為取余運算，而在Python中為取模運算）對於一個C語言取余表達式a % b，設其值為result，有如下公式

c++位運算符 | & ^ ~ && ||,補碼，反碼

編碼模塊規則中間變量成了位操作例如實現 a* 一：簡介 1 位邏輯運算符： & （位 “與”） and ^ （位 “異或”） | （位 “或”） or ~ （位 “取反”）

C++哪些運算符重載能夠重載？

哪些運算符能夠重載，哪些不可重載？

一些註意事項

模擬整型Integer

模擬指針Pointer

幾種特殊運算符的重載

operator new與operator delete

相關推薦