運算符重載的本質理解和數組運算符重載的實現

時間  2019-11-12
標籤 運算符 重載 本質 理解 數組 實現 简体版
原文   原文鏈接

        瞭解了運算符重載，就會以爲其十分的簡單。ios

        所謂重載，就是從新賦予新的意義。函數重載就是對於一個已有的函數從新賦予新的含義，使之實現新的功能。運算符也能夠重載，在咱們進行整數間的加法時，C++編譯器已經對+運算符進行了重載。又如咱們在使用位運算符<<、>>進行輸入和輸出操做時，C++系統已經分別重載了流對象cin和cout的<<、>>運算符，咱們只需引入頭文件iostream（固然還應當包括」using namespace std「）。數組

運算符重載的設計初衷

        因爲每一個數據類型都有本身的運算符規則，C++編譯器只是重載了基本數據類型的的運算符，對於複雜的數據類型（自定義的類），因爲其定義者對其的運算規則要求不一樣，因此C++編譯器就把重載複雜數據類型運算符的任務交給了其定義者，定義者能夠根據本身的須要重載複雜數據類型的運算符。函數

運算符重載本質

        就是一個函數，用來從新定義複雜的數據類型實例對象（同類型）間運算規則的函數。this

運算符重載的使用

        使用的兩種方式：一、全局函數實現     二、類的成員函數實現spa

        使用步驟(按照這個步驟來就很簡單)設計

          1）要認可操做符重載是一個函數，寫出函數名稱operator+ () 指針

          2）根據操做數，寫出函數參數（若是全局函數實現，要多一個這類的對象參數；若是是成員函數，少一個這類的對象參數）code

         3）根據業務，完善函數返回值(看函數是返回引用 仍是指針 元素)，及實現函數業務對象

 

實現數組運算符重載代碼

下面的例子是實現了自定義數組的    =（包括鏈式）、[]、== 、!=的運算符重載內存

數組類頭文件 ArrayCls.h

#pragma once
#include <iostream>
using namespace std;
class ArrayCls
{
public:
	ArrayCls(int lengh);

	ArrayCls( ArrayCls& obj);

	int length();

	int getData(int i);

	void setData(int i,int j);

	int& operator[](int num);        //[]運算符重載，能夠根據下標獲取數據，也可設置數據

	bool operator==(ArrayCls& arr1);    //==運算符重載，判斷數組的兩個對象是否相等

	bool operator!=(ArrayCls& arr1);    //!=運算符重載，判斷數組的兩個對象是否不相等

	ArrayCls& operator=(ArrayCls& arr1); //=賦值運算符重載，將數組的對象賦值給另外一個數組對象

	friend ostream& operator<<(ostream& out,ArrayCls arr1);    // <<左移運算符重載，輸出數組的數據到屏幕中

	friend istream& operator>>(istream& in,ArrayCls& arr1);    // >>右移運算符重載，從屏幕中給數組中的元素賦值

	~ArrayCls(void);
private:
	int mLength;
	int *mSpace;
};

數組cpp文件 ArrayCls.cpp

#include "ArrayCls.h"
#include <string.h>

ArrayCls::ArrayCls(int lengh)
{
	mLength = lengh;
	mSpace = new int[lengh];
}

ArrayCls::ArrayCls(ArrayCls& obj)
{
	mLength = obj.length();
	mSpace = new int[mLength];
	for(int i=0; i<mLength; i++)
	{
		this->setData(i,obj.getData(i));
	}
}

int ArrayCls::length()
{
	return mLength;
}

int ArrayCls::getData(int i)
{
	return mSpace[i];
}

void ArrayCls::setData(int i,int j)
{
	 mSpace[i] = j;
}

int& ArrayCls::operator[](int num)
{
	return this->mSpace[num];
}

bool ArrayCls::operator==(ArrayCls& arr1)
{
	int i = 0,len = this->length();
	if(len != arr1.length())
		return false;

	for(i=0; i<len; i++)
	{
		if(this->mSpace[i] != arr1[i])
		{
			return false;
		}
	}
	return true;
}

bool ArrayCls::operator!=(ArrayCls& arr1)
{
	return !(arr1 == *this);
}

ArrayCls& ArrayCls::operator=(ArrayCls& arr1)
{
	int i=0, len=arr1.length();
	//清理this的內存
	if(this->mSpace != NULL)
	{
		delete []this->mSpace;
	}
	//給this分配內存
	this->mSpace = new int[arr1.length()];
	//賦值
	for(i=0; i<len; i++)
	{
		this->mSpace[i] = arr1[i];
	}
	this->mLength = len;

	return *this;
}

ArrayCls::~ArrayCls(void)
{
	if(mSpace != NULL)
	{
		delete []mSpace;
		mSpace = NULL;
		mLength = -1;
	}
}

 main文件

#include <iostream>
using namespace std;
#include "ArrayCls.h"

/* 使用友元函數重載<<運算符 ，由於此兩目運算的左操做量不是對象自己，而是ostream的，
因此須要經過友元函數訪問對象的私有成員。*/
ostream& operator<<(ostream& out,ArrayCls arr1)
{
	int i=0, len=arr1.mLength;
	for(i=0; i<len; i++)
	{
		out<<arr1[i]<<" ";
	}
	out<<"   len="<<len<<endl;

	return cout;
}
/* 使用友元函數重載istream的>>運算符*/
istream& operator>>(istream& in,ArrayCls& arr1)
{
	int i=0,len = arr1.mLength;
	for(i=0; i<len; i++)
	{
		cin>>arr1[i];
	}
	return cin;
}

int main()
{
	int i=0,j=0;
	ArrayCls arr = ArrayCls(20);
	
	/*沒有使用運算符重載 設置、獲取數組*/
	for(i=0; i<arr.length();i++)
	{
		arr.setData(i,2*i+1);
	}
	for(i=0; i<arr.length();i++)
	{
		j = arr.getData(i);
		cout<<" "<<j;
	}
	cout<<endl;      //輸出    1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39

	
	/*[]運算符重載  arr[1]—>獲取值   arr[1]=1 —>設置值   函返回值當左值，須要返回一個引用*/
	//arr[1] = 5     int& operator[](int num);
	arr[1] = 5;
	cout<<"arr[1]="<<arr[1]<<endl;    //輸出    arr[1]=5

	
	/*  ==運算符重載   */
	//arr1==arr2	bool operator==(ArrayCls& arr1); 
	ArrayCls arr1 = ArrayCls(5);
	ArrayCls arr2 = ArrayCls(5);
	for(i=0; i<arr1.length();i++)
	{
		arr1[i] = 2*i;
		arr2[i] = 3*i;
	}
	if(arr1 == arr2)
	{
		cout<<"arr1 == arr2"<<endl;
	}
	else
	{
		cout<<"arr1 != arr2"<<endl;
	}                            //輸出     arr1 != arr2
    
    
	/*  != 運算符重載 */
	//arr1 != arr2		bool operator!=(ArrayCls& arr1);
	if(arr1 != arr2)
	{
		cout<<"arr1 != arr2"<<endl;
	}
	else
	{
		cout<<"arr1 == arr2"<<endl;
	}                                    //輸出     arr1 != arr2

	
	/*  =運算符重載  */
	//arr1=arr2=arr3 鏈式返回一個引用    ArrayCls& operator=(ArrayCls& arr1);
	ArrayCls arr3 = ArrayCls(1);
	arr3 = arr2 = arr1;
	for(i=0; i<arr3.length();i++)
	{
		cout<<i<<":arr3="<<arr3[i]<<"  arr2="<<arr2[i]<<" arr1="<<arr1[i]<<endl;
	}                                          
	/* 輸出： 0:arr3=0  arr2=0 arr1=0
                 1:arr3=2  arr2=2 arr1=2
                 2:arr3=4  arr2=4 arr1=4
                 3:arr3=6  arr2=6 arr1=6
                 4:arr3=8  arr2=8 arr1=8*/
                   
                                                                            
	/* << 輸出運算符重載 */
	/* cout<<arr1     ostream& operator<<(ostream& out,ArrayCls arr1); 
		注意：這個雙目運算符的左側運算量是 cout，不是ArrayCls類的對象自己，咱們就只能使用友元函數來訪問對象的私有成員*/
	cout<<arr1;            //輸出        0 2 4 6 8    len=5

	
	/* >> 輸入運算符重載*/
	/* cin>>arr1     istream& operator>>(istream& in,ArrayCls& arr1); 
		注意：這個雙目運算符的左側運算量是 cin，不是ArrayCls類的對象自己，咱們就只能使用友元函數來訪問對象的私有成員*/
	cin>>arr1;
	cout<<arr1;
	
	system("pause");
	return 0;
}

實現字符串運算符重載代碼

本實例實現了字符串的=、==、<<(輸出)、>>（輸入）、<（小於）、>（大於）運算符的重載

MyString類 頭文件

#pragma once
#include <iostream>
using namespace std;

class MyString
{
public:
	MyString(void);
	MyString(char *pStr);

	void printString();	//打印字符串函數
	MyString& operator=(MyString &str);	// =運算符
	bool operator==(MyString &str);		// ==運算符
	bool operator<(MyString &str);		// <運算符
	bool operator>(MyString &str);		// >運算符
	friend ostream& operator<<(ostream& cout,MyString& str);//左移運算符重載的友元函數
	friend istream& operator>>(istream& cin,MyString& str); //右移運算符重載的友元函數

	~MyString(void);
private:
	int		m_iLen;
	char	*m_pSpace;
};

MyString類     cpp文件

#include "MyString.h"
#include <iostream>
using namespace std;

MyString::MyString(void)
{
	m_iLen = 1;
	m_pSpace = new char[m_iLen];
	m_pSpace[m_iLen-1] = '\0';
}

MyString::MyString(char *pStr)
{
	m_iLen = strlen(pStr)+1;
	m_pSpace = new char[m_iLen];
	strcpy(m_pSpace,pStr);
}

void MyString::printString()
{
	cout<<"MyString :"<<m_pSpace<<endl;
}

MyString& MyString::operator=(MyString &str)
{
	if(m_pSpace != NULL)
	{
		delete []m_pSpace;
	}

	m_iLen = str.m_iLen;
	m_pSpace = new char[m_iLen];
	strcpy(m_pSpace,str.m_pSpace);

	return *this;
}

bool MyString::operator==(MyString &str)
{
	if(this->m_iLen != str.m_iLen)
	{
		return false;
	}
	if(strcmp(this->m_pSpace,str.m_pSpace) == 0)
	{
		return true;
	}
	return false;
}

bool MyString::operator<(MyString &str)
{
	if(strcmp(this->m_pSpace,str.m_pSpace) < 0)
	{
		return true;
	}
	return false;
}

bool MyString::operator>(MyString &str)
{
	if(strcmp(this->m_pSpace,str.m_pSpace) > 0)
	{
		return true;
	}
	return false;
}

MyString::~MyString(void)
{
	if(m_pSpace != NULL)
	{
		delete []m_pSpace;
		m_pSpace = NULL;
		m_iLen = -1;
	}
}

   操做字符串main文件

#include <iostream>
using namespace std;
#include "MyString.h"

//左移運算符重載，cout不是MyString類的對象自己，咱們就只能使用友元函數來訪問對象的私有成員
ostream& operator<<(ostream& cout,MyString& str)
{
	cout<<str.m_pSpace;
	return cout;
}
//右移運算符重載，cin不是MyString類的對象自己，咱們就只能使用友元函數來訪問對象的私有成員
istream& operator>>(istream& cin,MyString& str)
{
	char temp[1024] = {0};
	cin>>temp;
	str = MyString(temp);
	return cin;
}

int main()
{
	//構造函數 
	MyString str = MyString("asdfasdf");
	str.printString();

	// =運算符		MyString& operator=(MyString &str)
	MyString str2 = str;
	str2.printString();

	// <<運算符	ostream& operator<<(ostream os,MyString& str);
	cout<<"str2:"<<str2<<endl;

	// >>運算符	istream& operator>>(istream& cin,MyString& str);
	MyString str3,str4;
	cin>>str3>>str4;
	cout<<"str3:"<<str3<<"    str4:"<<str4<<endl;

	// ==運算符	bool operator==(MyString &str);
	if(str3 == str4)
	{
		cout<<"str3 == str4"<<endl;
	}
	else
	{
		cout<<"str3 != str4"<<endl;
	}

	// <運算符		bool operator<(MyString &str);
	if(str3 < str4)
	{
		cout<<"str3 < str4"<<endl;
	}
	else
	{
		cout<<"str3 !< str4"<<endl;
	}
	
	// >運算符		bool operator>(MyString &str);
	if(str3 > str4)
	{
		cout<<"str3 > str4"<<endl;
	}
	else
	{
		cout<<"str3 !> str4"<<endl;
	}
	
	system("pause");
	return 0;
}

最後但願能對你們有幫助，沙米才疏學淺，有什麼錯誤請留言指正，謝謝你們。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程