C++运算符重载

一、概念

1、什么是运算符重载

所谓重载，就是重新赋予新的含义。

2、运算符重载的限制

二、运算符重载的基础

1、运算符重载本质是一个函数，函数名字组成：operator+要重载的运算符

2、运算符重载的步骤：

（1）写函数名：operator+要重载的函数名

（2）根据运算需求写函数的参数列表

（3）根据需求写出函数返回值的类型

#include <stdio.h>

class Complex
{
public:
	Complex()
	{
		m_a = 0;
		m_b = 0;
	}

	Complex(int a,int b)
	{
		m_a = a;
		m_b = b;
	}

	void print()
	{
		printf("%d + %di\n",m_a,m_b);
	}

	Complex operator+(Complex &b)
	{
		Complex tmp(m_a + b.m_a,m_b + b.m_b);

		return tmp;
	}

	Complex operator-(Complex &b)
	{
		Complex tmp(m_a - b.m_a,m_b - b.m_b);

		return tmp;
	}

private:
	int m_a;
	int m_b;
};

int main()
{
	Complex c1(1,2),c2(2,3),c4(2,2),c3;

	c1.print();
	c2.print();

	c3 = c1 + c2 - c4;
	c3.print();

	return 0;
}

三、前置和后置操作符重载

1、C++中通过一个占位参数来区分前置运算和后置运算

#include <stdio.h>

class Complex
{
public:
	Complex()
	{
		m_a = 0;
		m_b = 0;
	}

	Complex(int a,int b)
	{
		m_a = a;
		m_b = b;
	}

	void print()
	{
		printf("%d + %di\n",m_a,m_b);
	}

	Complex operator+(Complex &b)
	{
		Complex tmp(m_a + b.m_a,m_b + b.m_b);

		return tmp;
	}

	Complex &operator++()
	{
		++m_a;
		++m_b;

		return *this;
	}

	Complex operator++(int)
	{
		Complex tmp(m_a,m_b);
		m_a++;
		m_b++;

		return tmp;
	}

private:
	int m_a;
	int m_b;
};

int main()
{
	Complex c1(1,2),c2(2,3),c4(2,2),c3;

	c1.print();
	c2.print();

	c3 = (c1++) + (++c1) + (++c1);

	c3.print();
	c1.print();

	return 0;
}

四、友元函数实现操作符重载

1、当无法修改左操作数的类时，使用全局函数进行重载

2、友员函数重载运算符常用于运算符的左右操作数类型不同的情况

#include <iostream>

using namespace std;

class Complex
{
	friend ostream &operator<<(ostream &out,const Complex &obj);

public:
	Complex()
	{
		m_a = 0;
		m_b = 0;
	}

	Complex(int a,int b)
	{
		m_a = a;
		m_b = b;
	}

private:
	int m_a;
	int m_b;
};

ostream &operator<<(ostream &out,const Complex &obj)
{
	out << obj.m_a << "+" << obj.m_b << "i";

	return  out;
}

int main()
{
	Complex c1(1,2);

	cout << c1 << endl;

	return 0;
}

五、赋值运算符重载

1、赋值运算符重载函数必须为成员函数

2、如果没写自定义的 赋值运算符重载，编译器会有一个默认的赋值运算符重载函数，默认赋值运算符做的是一些简单的拷贝，是浅拷贝

#include <iostream>
#include <string.h>

using namespace std;

class Student
{
	friend ostream &operator<<(ostream &out,const Student &obj);

public:
	Student()
	{
		m_id = 0;
		m_name = NULL;
	}

	Student(int id,char *name)
	{
		m_id = id;
		int len = strlen(name);
		m_name = new char[len + 1];
		strcpy(m_name,name);
	}

	Student(const Student &obj)
	{
		m_id = obj.m_id;
		int len = strlen(obj.m_name);
		m_name = new char[len + 1];
		strcpy(m_name,obj.m_name);
	}

	Student &operator=(const Student &obj)
	{
		if(this == &obj)
			return *this;

		if(m_name != NULL)
		{
			delete []m_name;
			m_name = NULL;
		}

		int len = strlen(obj.m_name);
		m_name = new char[len + 1];
		m_id = obj.m_id;
		strcpy(m_name,obj.m_name);

		return *this;
	}

	~Student()
	{
		if(m_name != NULL)
		{
			delete []m_name;
			m_name = NULL;
		}
		m_id = 0;
	}
private:
	int m_id;
	char *m_name;
};

ostream &operator<<(ostream &out,const Student &obj)
{
	out << "id = " << obj.m_id << ",name = " << obj.m_name;
	return out;
}

int main()
{
	Student s1(10,"wang");
	Student s2 = s1;
	Student s3;
	s3 = s3 = s1;

	cout << s1 << endl;
	cout << s2 << endl;
	cout << s3 << endl;

	return 0;
}

六、括号运算符重载

#include <stdio.h>

class Test
{
public:
	Test(int a)
	{
		m_a = a;
	}

	void print()
	{
		printf("a = %d\n",m_a);
	}

	void operator()(int num)
	{
		printf("a = %d\n",num);
	}
private:
	int m_a;
};

int main()
{
	Test t(10);
	t.print();

	t(20);

	return 0;
}

七、逻辑与和逻辑或

1、&&和||是C++中非常特殊的操作符 

2、&&和||内置实现了短路规则 

3、操作符重载是靠函数重载来完成的 

4、操作数作为函数参数传递 

5、C++的函数参数都会被求值，无法实现短路规则