C++哪些运算符重载能够重载？

运算符重载是C++极为重要的语言特性之中的一个。本文将用代码实例回答——C++哪些运算符能够重载？怎样重载？实现运算符重载时须要注意哪些？

哪些运算符能够重载，哪些不可重载？

C++98，C++0x，C++11对“哪些运算符重载能够重载”有一致的规定。详细例如以下：

当中，非常少使用的是“,”（逗号运算符）。

标准相同规定了不可重载的运算符：

当中，“::”是作用域运算符。

“?:”是条件运算符。

两个较少使用的运算符是 .* 和 ->* 各自是：

.* 对象调用成员函数指针；

->* 对象指针调用成员函数指针。

标准还指出，有的运算符能够同一时候支持“一元运算”和“二元运算”：

下文通过实现几个模拟内置类型的类来展示详细的运算符重载方法应当怎样实现。

一些注意事项

实现运算符重载时应注意：

1. 运算符重载不改变运算符的优先级与结合性，如/的优先级比-高;
2. 运算符重载不改变部分运算符对操作数个数的限制，如+仅仅能有两个操作数;

模拟整型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

[]，下标运算

++，自增

--，自减

+，加法

-，减法

有一点值得注意的是：

1. 每种类型都相应一种指针，如int相应int*；
2. 解引用和下标运算的返回结果能够做“左值”（赋值运算符左边的值。即能够赋值）。
3. 指针的加减，-是以指针当前类型的大小为单位的。即：若有指针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的重载，下次另外写博客阐释。