2. 程式人生 > >C++的操作符過載

C++的操作符過載

阿新 • • 發佈：2018-11-10

一、操作符標記和操作符函式

1、雙目操作符：L#R

成員函式形式：L.operator# (R) —— 左調右參
全域性函式形式：::operator#（L，R） —— 左一右二

2、單目操作符：#O/O#

成員函式形式：O.operator#()
全域性函式形式：::operator#(O)

3、三目操作符：不考慮

二、雙目操作符

1、+/-/*//

運算元在計算前後不變；表示式的值是右值。

#include <iostream>
using namespace std;

class Complex{
public:
	Complex(int r = 0,int i = 0) : m_r(r), m_i(i){}
	void print() const{
		cout << m_r << "+" << m_i << "i" << endl;
	}
	//第一個const：返回右值
	//第二個const：支援常量型右運算元
	//第三個const：支援常量型左運算元
	const Complex operator+(const Complex& r) const{
		return Complex(m_r + r.m_r, m_i + r.m_i);
	}
private:
	int m_r;
	int m_i;
	friend const Complex operator-(const Complex&,const Complex&);//友元
};

const Complex operator-(const Complex& l,const Complex& r){
	return Complex(l.m_r - r.m_r,l.m_i - r.m_i);
}

int main(){
	Complex c1(1,2);
	c1.print();
	Complex c2(3,4);
	Complex c3 = c1 +c2;//c3 = c1.operator+(c2);
	c3.print();//4+6i
	c3 = c2 - c1;//c3 = ::operator-(c2,c1);
	c3.print();//2+2i
	return 0;
}

2、複合賦值運算子：+=/-=/*=…

左變右不變
表示式的值是左值，左運算元的引用。
（a += b） = c;

#include <iostream>
using namespace std;

class Complex{
public:
	Complex(int r = 0, int i = 0) : m_r(r), m_i(i){}
	void print(void) const{
		cout << m_r << '+' << m_i << 'i' << endl;
	}
	Complex& operator+=(const Complex& r){
		m_r += r.m_r;
		m_i += r.m_i;
		return *this;
	}
	friend Complex& operator-= (Complex& l, const Complex& r){//友元函式，是個全域性函式，不是成員函式，寫類裡面和外面都行
		l.m_r -= r.m_r;
		l.m_i -= r.m_i;
		return l;
	}
private:
	int m_r;
	int m_i;
};

int main(void){
	Complex c1(1,2), c2(3,4);
	c1 += c2;//c1.operator+= (c2)
	c1.print();//4+6i
	Complex c3(5,6);
	(c1 += c2) = c3;
	c1.print();//5+6i

	c1 -= c2;//::operator-= (c1,c2)
	c1.print();//2+2i
	(c1 -= c2) = c3;
	c1.print();
	return 0;
}

3、<< / >>

int i = 10;
float f = 1.23;
Complex c (…);
cout << c << i << f << endl;
左運算元ostream/istream型別，不能是常量，不能拷貝。
右運算元自定義型別，對於<<可以是常量，對於>>不能是常量。
表示式的值是左運算元的引用。
::operator<< (cout, c).operator<< (i).operator<< (f).operator<< (endl);

#include <iostream>
using namespace std;

class Complex{
public:
	Complex(int r = 0, int i = 0) : m_r(r), m_i(i){}
	void print(void) const{
		cout << m_r << '+' << m_i << 'i' << endl;
	}
	friend ostream& operator<< (ostream& os,const Complex& r){
		return os << r.m_r << '+' << r.m_i << 'i';
	}
	friend istream& operator>> (istream& is,Complex& r){
		return is >> r.m_r >> r.m_i;
	}
private:
	int m_r;
	int m_i;
};

int main(void){
	Complex c1(1,2),c2(3,4);
	cout << c1 << endl << c2 << endl;
	//::operator<< (::operator << (cout,c1).operator<<(endl),c2).operator<< (endl);

	cin >> c1 >> c2;
	c1.print();
	c2.print();
	return 0;
}

三、單目操作符

1、-（取負）/！/~

運算元不變。
表示式的值是右值。

#include <iostream>
using namespace std;

class Complex{
public:
	Complex(int r = 0, int i = 0) : m_r(r), m_i(i){}
	void print(void) const{
		cout << m_r << '+' << m_i << 'i' << endl;
	}
	const Complex operator-(void) const{
		return Complex(-m_r,-m_i);
	}
	friend const Complex operator~(const Complex& o){
		return Complex(o.m_i,o.m_r);
	}
private:
	int m_r;
	int m_i;
};

int main(void){
	Complex c1(1,2);
	Complex c2 = -c1;//c2 = c1.operator-()
	c2.print();//-1-2i
	Complex c3 = ~c1;//c3 = ::operator~(c1)
	c3.print();
	return 0;
}

2、前++/前–

運算元變。
表示式的值是運算以後的值。
表示式的值是左值，運算元的引用。

#include <iostream>
using namespace std;

class Complex{
public:
	Complex(int r = 0, int i = 0) : m_r(r), m_i(i){}
	void print(void) const{
		cout << m_r << '+' << m_i << 'i' << endl;
	}
	Complex& operator++(void){
		++m_r;
		++m_i;
		return *this;
	}	
	friend Complex& operator-- (Complex& o){
		--o.m_r;
		--o.m_i;
		return o;
	}
private:
	int m_r;
	int m_i;
};

int main(void){
	Complex c1(1,2);
	Complex c2 = ++c1;//c2 = c1.operator++()
	c1.print();//2+3i
	c2.print();//2+3i
	(++c1) = Complex(10,20);
	c1.print();//10+20i
	(++++++c1).print();

	c2 = --c1;//c2=::operator
	c1.print();//12+22i
	c2.print();//12+22i
	return 0;
}

3、後++/後–

運算元變。
表示式的值是運算以前的值。
表示式的值是右值。

#include <iostream>
using namespace std;

class Complex{
public:
	Complex(int r = 0, int i = 0) : m_r(r), m_i(i){}
	void print(void) const{
		cout << m_r << '+' << m_i << 'i' << endl;
	}
	const Complex operator++(int){
		Complex old(*this);
		++m_r;
		++m_i;
		return old;
	}
	friend const Complex operator-- (Complex& o,int){
		Complex old(o);
		--o.m_r;
		--o.m_i;
		return old;
	}
private:
	int m_r;
	int m_i;
};

int main(void){
	Complex c1(1,2);
	Complex c2 = c1++;//c2=c1.operator++(0)
	c1.print();//2+3i
	c2.print();//1+2i
	//(c1++) = c2;
	//c1++++++;

	c2 = c1--;//c2::operator--(c1,0)
	c1.print();//1+2i
	c2.print();//2+3i
	return 0;
}

四、其他操作符

1、下標操作符：[]

雙目操作符，左運算元是一個具有容器特性的物件，右運算元是容器中特定資料元素的索引（基零的下標）。
下標表達式的值可以是左值，也可以是右值，由容器物件的常屬性決定。常容器下標表達式的值是右值，非常容器下標表達式的值是左值。

#include <iostream>
using namespace std;

class Array{
public:
	Array(size_t size = 1) : m_data(new int[size]){}
	~Array(void){
		if (m_data){
			delete m_data;
			m_data = NULL;
		}
	}
	int& operator[] (size_t i){
		return m_data[i];
	}
	const int& operator[] (size_t i) const{
		return const_cast<Array&> (*this)[i];
	}
private:
	int* m_data;
};

int main(void){
	Array arr(10);
	for (size_t i = 0;i < 10;++i)
		arr[i] = i;//arr.operator[](i) = i;
	arr[0]++;

	const Array& cr = arr;
	for (size_t i = 0;i < 10;++i)
		cout << cr[i] << ' ';
	cout << endl;
	//cr[0]++;
	return 0;
}

2、函式操作符：（）

如果為一個類定義了形如：
返回型別 operator() （形參表）{…}
的操作符函式，那麼這個類所例項化的物件就可以被當做函式使用。

3、解引用（*）和間接訪問（->）操作符

以指標的方式使用類型別的物件。

#include <iostream>
#include <memory>
using namespace std;

class A{
public:
	A(void){
		cout << "構造" << endl;
	}
	~A(void){
		cout << "析構" << endl;
	}
	void hello(void){
		cout << "Hello,World!" << endl;
	}
};

class PA{
public:
	PA(A* p = NULL) : m_p(p){}
	~PA(void){
		if (m_p){
			delete m_p;
			m_p = NULL;
		}
	}
	A& operator*(void) const{
		return *m_p;
	}
	A* operator->(void) const{
		return &(**this);
	}
	PA(PA& that) : m_p(that.release()){}
	PA& operator= (PA& that){
		if (&that != this)
			reset(that.release());
		return *this;
	}
private:
	A* m_p;
	A* release(void){
		A* p = m_p;
		m_p = NULL;
		return p;
	}
	void reset(A* p){
		if (p != m_p){
			delete m_p;
			m_p = p;
		}
	}
};

void bar(auto_ptr<A> pa){
	cout << "bar:";
	pa->hello();
}

void foo(void){
	//A* pa = new A;
	//delete pa;
	//A a;

	PA pa(new A);
	pa -> hello();//pa.operator->()->hello();
	(*pa).hello();//pa.operator*().hello();

	PA pb = pa;
	pb->hello();//pa就不能用啦

	auto_ptr<A> pa1(new A);//智慧指標模板
	pa1->hello();
	auto_ptr<A> pa2 = pa1;
	(*pa2).hello();

	bar(pa2);
	cout << pa2.get() << endl;//get()函式取指標的值
}

//smart_ptr，2011標準中的智慧指標，可實現

int main(void){
	foo();
	return 0;
}

4、自定義型別轉換和型別轉換操作符

（1）通過單參構造實現自定義型別轉換
如果A類中有一個可以接受B類物件作為唯一引數的建構函式，那麼B型別的物件就可以根據該建構函式被轉換為A型別。
通過explicit關鍵字，可以強制使用該建構函式所完成的型別轉換必須顯示進行。
（2）通過型別轉換操作符函式實現自定義型別轉換，如果A類中有一個形如
operator B (void) const{ … }
的操作符函式，那麼A型別的物件就可以根據該函式被轉換為B型別。

如果目標型別是類型別，源型別是基本型別，那麼就只能通過在目標型別中定義以源型別為單參的建構函式實現型別轉換。
如果目標型別是基本型別，源型別是類型別，那麼就只能通過在源型別中定義以目標型別為函式名的型別轉換操作符函式實現型別轉換。
如果目標型別和源型別都是類型別，那麼以上兩種方法任取其一，但是不能同時使用。
如果目標型別和源型別都是基本型別，那麼無法實現自定義型別轉換。

#include <iostream>
using namespace std;

class Square{
public:
	double operator() (double x){
		return x * x;
	}
};

class Integer{
public:
	explicit Integer(int i = 0) : m_i(i){}//explicit關鍵字規定使用顯示單參構造型別轉換
	void print(void) const{
		cout << m_i << endl;
	}
	Integer& operator()(int i){
		m_i += i;
		return *this;
	}
	operator int(void) const{//型別轉換操作符
		return m_i;
	}
private:
	int m_i;
};

void foo(const Integer& i){
	i.print();
}

Integer bar(void){
	return Integer(300);
}

int main(void){
	Square square;
	cout << square(3) << endl;
	//cout << square.operator()(3) << endl;

	Integer i(10);
	i(1)(2)(3)(17);
	i.print();//33

	i = (Integer)100;
	i.print();
	foo(static_cast<Integer> (200));
	bar().print();

	int n = i;
	cout << n << endl;
	return 0;
}

5、new/delete操作符

#include <iostream>
#include <cstdlib>
using namespace std;

class A{
public:
	~A(void){}
	static void* operator new (size_t size){
		void* p = malloc(size);
		cout << "自定義new：" << p << ' ' << size << endl;
		return p;
	}
	static void operator delete(void* p){
		cout << "自定義delete：" << p << endl;
		free(p);
	}
	static void* operator new[] (size_t size){
		void* p = malloc(size);
		cout << "自定義的new[]:" << p << ' ' << size << endl;
		return p;
	}
	static void operator delete[] (void* p){
		cout << "自定義的delete[]:" << p << endl;
		free(p);
	}
private:
	int m_i;
	double m_d;
	char m_c;
};

int main(void){
	cout << sizeof(A) << endl;
	A* pa = new A;
	cout << pa << endl;
	delete pa;

	pa = new A[2];
	cout << pa << endl;
	delete[] pa;
	return 0;
}

五、關於操作符過載的限制

1、至少有一個運算元是類型別的。

int a = 10, b = 20;
int c = a + b;//200
int operator+ (int a, int b){
return a * b;
}//ERROR!

2、不是所有的操作符都能過載。

:: —— 作用域限定
. —— 直接成員訪問
.* —— 直接成員指標解引用
?: —— 三目運算子
sizeof —— 獲取位元組數
typeid —— 獲取型別資訊

3、不是所有的操作符都可以用全域性函式的方式實現。

= —— 拷貝賦值
[] —— 下標操作符
() —— 函式操作符
-> —— 間接成員訪問

4、不能發明新的操作符

相關推薦

白話文說c++ 操作符過載

前言 c++操作符過載的背景主要是原有的操作符+ - += 等只能運算基本資料型別 int double這些，但是實際中我們經常遇到很多自定義的型別，比如複數 結構體等，比如要計算1+2i 與2+3i這兩個複數的和或者比大小，計算機就沒有直接的方法進行計算，這時候，運算子過載起到了很大的作用

C++ 操作符過載（小結 持續更新ing ）(歡迎收藏)

操作符過載一個原則是：被操作的資料型別中 至少有一個是自定義的型別（使用class定義類），如果被操作的變數都是基本型別，那麼就不能定義操作符過載。 如果過載了new,則必須過載delete,因為系統知道了你自定義了怎麼new一個空間， 但是呢，你使用delete的時候，系統並

C++操作符過載總結operator（小結 更新ing）

#include <iostream> #include<string.h> #include<stdlib.h> using namespace std; /*操作符過載一個原則是：被操作的資料型別，至少有一個是自定義的型別， * 如果被操作的變數都是基本型別，那麼

c++操作符過載多檔案形式練習

Array.h#pragma once//標頭檔案中宣告的函式，編譯器會自動去各.cpp檔案去匹配物件的具體定義//標頭檔案中不能包含.cpp檔案，編譯時候會報錯誤，但可以包含其他的.h標頭檔案//標頭檔案中不能定義函式的具體內容，只可以宣告函式，但可以定義型別，如果型別裡包

c# 操作符過載小結

C#操作符過載是什麼？ 是指允許使用者使用使用者定義的型別編寫表示式的能力。 例如，通常需要編寫類似於以下內容的程式碼，以將兩個數字相加。很明顯，sum 是兩個數字之和。 int i = 5; int sum = i + j; 如果可以使用代表複數的使用者定義的型別來編寫

C#中如何利用操作符過載和轉換操作符 （轉載）

操作符過載 有的程式語言允許一個型別定義操作符應該如何操作型別的例項，比如string型別和int型別都過載了（==）和（+）等操作符，當編譯器發現兩個int型別的例項使用+操作符的時候，編譯器會生成把兩個整數加到一起的程式碼。當編譯器發現兩個string型別的例項使用+操作符的時候，編譯器會生成把兩個

1、【C++】類&物件/建構函式/拷貝建構函式/操作符過載/解構函式

一、C++類 & 物件     C++ 在 C 語言的基礎上增加了面向物件程式設計，C++ 支援面向物件程式設計。類是 C++ 的核心特性，通常被稱為使用者定義的型別。     類用於指定物件的形式，它包含了資料表示法和用於處理資料的方法。類中的資料和方法稱為類的成員。函式在

C++筆記 第三十課 操作符過載的概念---狄泰學院

如果在閱讀過程中發現有錯誤，望評論指正，希望大家一起學習，一起進步。 學習C++編譯環境：Linux 第三十課 操作符過載的概念 1.需要解決的問題 下面的複數解決方案是否可行？ 30-1 複數的加法操作 #include <stdio.h> class

C++的操作符過載

一、操作符標記和操作符函式 1、雙目操作符：L#R 成員函式形式：L.operator# (R) —— 左調右參 全域性函式形式：::operator#（L，R） —— 左一右二 2、單目操作符：#O/O# 成員函式形式：O.operator#() 全域性函式形式：::o

C++ 中指標操作符(*)過載備忘

下面程式碼可以編譯通過，從程式碼中可以看出只要過載了指定物件的指標操作符過載時，編譯器會自動轉成父類指標型別 class OverLoadObjABase { public: int x; }; class OverLoadObjA: public OverLoadObjABase {

c++實現日期類(class Date) 建構函式 拷貝構造 操作符過載（輸入輸出 比較操作 算數運算 自增自減）

註釋比較詳細，可以直接跑起來，直接上程式碼（vs2012 win7） 一、標頭檔案 /************** Date.h ***************/ #pragma once #include <iostream> using name

C++學習筆記（七）--操作符過載 友元函式 類的繼承 訪問控釋protected

C++ Primer Plus的閱讀大概到這邊也就先暫時告一段落了（因為開學了！！） 然後近期找來了C++ Primer稍微翻了翻覺得確實寫得比Plus要好一些，而且加入了C++11的新特性，但是無論哪本書對於這些最基本的功能應用大抵也是差不多的，所以也沒覺得看的是Plu

C#建構函式、操作符過載以及自定義型別轉換

構造器 　　構造器（建構函式）是將型別的例項初始化的特殊方法。構造器可分為例項構造器和型別構造器，本節將詳細介紹有關內容。 例項構造器 　　顧名思義，例項構造器的作用就是對型別的例項進行初始化。如果類沒有顯示定義任何構造器，C#編譯器會定義一個預設的無參構造器。相反，如果類

為什麼c++中過載流操作符要用友元函式

1.先來看看友元函式過載流操作符例項 class complex { public: complex(int x, int y): real(x), imag(y){} complex():complex(0,0){} ~complex(){}

C++的過載操作符（operator）介紹

本文主要介紹C++中的過載操作符（operator）的相關知識。1. 概述1.1 whatoperator 是C++的一個關鍵字，它和運算子（如=）一起使用，表示一個運算子過載函式，在理解時可將operator和運算子（如operator=）視為一個函式名。使用operato

對於c++中流操作符過載的理解

對於IO成員函式的過載不應該是一個成員函式的方式，並且應該宣告為友元 一、如果為成員函式，都會有一個某人的引數，也就是this指標，為左運算元，下面考慮將其宣告為成員函式的方式 對於cout<<t<<endl cout為左運算元，說明cout本身有

c++友元實現操作符過載

運算子過載的本質是一個函式 #include <iostream> using namespace std; class A { private: int m_a; int m_b; friend A operator+

C# bool true, false 操作符過載，用在 if, while等語句中

// Definitely true operator. Returns true if the operand is True, false // otherwise. public static bool operator true(DBBool

c++拷貝建構函式和賦值操作符過載

c++拷貝建構函式： class A { A(const A& a); .... } 由於拷貝建構函式中，一般不允許對原物件進行修改，因此一般在引數中使用const關鍵字進行限制。 拷貝建構函式一般用於需要new記憶體等操作。如果不允許使用拷貝建

【C++基礎】----操作符過載(03)

今天我們來討論操作符過載中比較重要的一個內容：賦值操作符的過載 1. 常量不允許出現在=左邊 由於編譯期對賦值有著嚴格的要求和限制，因此強制 operator=() 為成員函式。 成員函式的優點在於在呼叫時，永遠有一個隱式的this指標被呼叫，而反觀友元函式，我們可以將任何