常用的几种运算符重载

以下为常用的几种运算符重载

1、加号、减号运算符的重载

2、++、--运算符的重载

3、赋值运算符的重载

4、==与！=运算符的重载

5、[]与<<运算符的重载

注意：

[]返回值为左值需要返回一个引用。

<<操作符重载为链式重载，需要返回一个引用。

||和&&操作符一般不能重载，因为其具有短路原则。

 

1、加号、减号运算符的重载

#include "iostream"

using namespace std;

class Complex
{
public:
	Complex(int a, int b)
	{
		this->a = a;
		this->b = b;
	}
	void Show()
	{
		cout << a << "+" << b << "i" << endl;
	}
	friend Complex operator+(Complex &a1, Complex &a2);
	
	private:
	int a;
	int b;
};

Complex operator+(Complex &a1, Complex &a2)
{
	Complex tmp(a1.a + a2.a,a1.b+a2.b);
	return tmp;
}

int main()
{
	Complex a1(1, 2), a2(3, 4);
	Complex a3 = a1 + a2;
	a3.Show();
	system("pause");	
	return 0;
}		

 

2、++、--运算符的重载

++与--运算符分为前置++、--和后置++、--，因此要注意使用占位符来区分。

class  Complex1
{
public:
	Complex1(int a = 0, int b = 0)
	{
		this->a = a;
		this->b = b;
	}
	void Show()
	{
		cout << a << "+" << b << endl;
	}
	Complex1& operator++()  //前置++
	{
		this->a++;
		this->b++;
		return *this;
	}
	Complex1 operator++(int)  //后置++
	{
		Complex1 tmp = *this;
		this->a++;
		this->b++;
		return tmp;
	}
	Complex1& operator--()  //前置--
	{
		this->a--;
		this->b--;
		return *this;
	}
	Complex1 operator--(int)  //后置--
	{
		Complex1 tmp = *this;
		this->a--;
		this->b--;
		return tmp;
	}
private:
	int a;
	int b;
};

int main()
{
	Complex1 a1(1, 2);
	++a1;
	a1.Show();
	--a1;
	a1.Show();
	system("pause");
	return 0;
}

 

3、赋值运算符的重载

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;

class String
{
public:
	String(const char *str = NULL);				 // 通用构造函数
	String(const String &s);				// 拷贝构造函数
	~String();									// 析构函数
	String& operator = (const String &s);    // 赋值函数
	void operator==(const String &s);
	char& operator[](int index);
	friend ostream& operator<<(ostream& out, const String &s);
	void showStr()
	{
		cout << m_data << endl;
	}
private:
	char* m_data;        // 用于保存字符串
	int m_len;
};

//构造函数
String::String(const char *str)
{
	if (str == NULL)
	{
		m_data = new char[m_len + 1];
		strcpy(m_data, "\0");
	}
	else
	{
		m_len = strlen(str);
		m_data = new char[m_len + 1];
		strcpy(m_data, str);
	}
	//cout << "调用构造函数" << endl;
}

//拷贝构造函数
String::String(const String &s)
{
	m_len = strlen(s.m_data);
	this->m_data = new char[m_len + 1];
	strcpy(this->m_data, s.m_data);
	//cout << "调用拷贝构造函数" << endl;
}

//析构函数
String::~String()
{
	if (m_data != NULL)
	{
		delete[] m_data;
		m_data = NULL;
		m_len = 0;
	}
	//cout << "析构函数被调用" << endl;
}

//赋值函数
String& String::operator = (const String &s)
{
	if (m_data != NULL)
	{
		delete[] m_data;
		m_data = NULL;
		m_len = 0;
	}
	if (s.m_data == NULL)
	{
		m_len = 0;
		this->m_data = new char[m_len + 1];
		strcpy(m_data, "\0");
	}
	else
	{
		m_len = strlen(s.m_data);
		this->m_data = new char[m_len + 1];
		strcpy(m_data, s.m_data);
	}
	return *this;
}

int main()
{
	String s1("hello");
	s1.showStr();
	String s2("world");
	s1 = s2;
	s1.showStr();

	system("pause");
	return 0;
}

4、==与！=运算符的重载

class equ
{
public:
	equ(int a)
	{
		this->a = a;
	}
	void operator==(equ &a1);
	void operator!=(equ &a1);
private:
	int a;
};

void equ::operator==(equ &a1)
{
	if (this->a == a1.a)
	{
		cout << "相等" << endl;
	}
	else
	{
		cout << "不相等" << endl;
	}
}

void equ::operator!=(equ &a1)
{
	if (this->a != a1.a)
	{
		cout << "不相等" << endl;
	}
	else
	{
		cout << "相等" << endl;
	}
}
int main()
{
	equ q1(1);
	equ q2(2);
	equ q3(1);
	q1 == q2;
	q1 != q3;
	system("pause");
	return 0;
}

5、[]与<<运算符的重载

class String
{
public:
	String(const char *str = NULL);			// 通用构造函数
	String(const String &s);				// 拷贝构造函数
	~String();								// 析构函数
	String& operator = (const String &s);    // 赋值函数
	char& operator[](int index);
	friend ostream& operator<<(ostream& out, const String &s);
	void showStr()
	{
		cout << m_data << endl;
	}
private:
	char* m_data;        // 用于保存字符串
	int m_len;
};

//构造函数
String::String(const char *str)
{
	if (str == NULL)
	{
		m_data = new char[m_len + 1];
		strcpy(m_data, "\0");
	}
	else
	{
		m_len = strlen(str);
		m_data = new char[m_len + 1];
		strcpy(m_data, str);
	}
	//cout << "调用构造函数" << endl;
}

//拷贝构造函数
String::String(const String &s)
{
	m_len = strlen(s.m_data);
	this->m_data = new char[m_len + 1];
	strcpy(this->m_data, s.m_data);
	//cout << "调用拷贝构造函数" << endl;
}

//析构函数
String::~String()
{
	if (m_data != NULL)
	{
		delete[] m_data;
		m_data = NULL;
		m_len = 0;
	}
	//cout << "析构函数被调用" << endl;
}

//赋值函数
String& String::operator = (const String &s)
{
	if (m_data != NULL)
	{
		delete[] m_data;
		m_data = NULL;
		m_len = 0;
	}
	if (s.m_data == NULL)
	{
		m_len = 0;
		this->m_data = new char[m_len + 1];
		strcpy(m_data, "\0");
	}
	else
	{
		m_len = strlen(s.m_data);
		this->m_data = new char[m_len + 1];
		strcpy(m_data, s.m_data);
	}
	return *this;
}

//[]运算符重载
char& String::operator[](int index)
{
	return m_data[index];
}

//<<重载
ostream& operator<<(ostream& out, const String &s)
{
	out << s.m_data;
	return out;
}

int main()
{
	String s1("hello");
	cout << s1[1] << endl;
	
	system("pause");	
	return 0;
}