C++操作符重载：operator

1.重载

重载允许创建多个名称相同，但输入不同的函数，这些函数的参数列表不同，可以通过给予不同输入变量调用对应的函数。

函数重载的关键是函数的参数列表。如果两个函数的参数数量和类型相同，同时参数的排列顺序也相同，那么就是同一个函数，不构成重载，它与f返回值和变量名都无关。

void print(const char* str, int width);    //重载1
void print(int i, int width);              //重载2
void print(double d, int width);           //重载3
void print(long l, int width);             //重载4
void print(const char* str);               //重载5

但是，注意以下情况，C++允许对函数末尾的参数，设置初始值，如果出现这种情况，会导致找不到真正的函数实体，报出多个重载函数与参数列表匹配。

void print(const char* str, int width = 0);
void print(const char* str);

 2.operator关键字

C++中存在一种便携式的操作，可以将常用的操作符转化为函数，例如+-*/，通过函数的方式，让类的管理更加方便，具体实现方式为：operator符号

2.1.基本介绍

对于正常情况，一元运算符（具有一个输入）建议作为成员函数，二元运算符（具有二个输入）建议为友元函数。

::    ?    .    .*    sizeof 这些操作符不能重载。

=    ()    []    -> 这些操作符不能作为友元重载。

<< >> 这些操作符通常建议作为友元重载，否则无法实现流的连续调用。

2.2.= + - * / 重载

= + - * / 重载格式固定，都只能有一个参数，但类型和返回类型可以不确定。

class test {
public:
	test(int i = 0) :m_num(i) {};
	const test& operator+(int i) {
		m_num += i;
		return *this;
	}
    const test& operator+(const test& other) {    //可以使用不同输入
		m_num += other.m_num;
		return *this;
	}
	const test& operator-(int i) {
		m_num -= i;
		return *this;
	}
	const test& operator*(int i) {
		m_num *= i;
		return *this;
	}
	const test& operator/(int i) {
		m_num /= i;
		return *this;
	}
	const test& operator=(const test& other) {
		m_num = other.m_num;
		return *this;
	}
private:
	int m_num;
};
int main() {
	test t(1);
	t = t + 1;	// 1+1=2
	t = t - 3;	// 2-3=-1
	t = t * 4;  // -1*4=-4
	t = t / 2;  // -4/2=-2
	cout << t.getnum() << endl;
	return 0;
}

2.3.++ -- ! 重载

++和--操作符重载，如果存在参数，代表后++，如果没有参数，代表前++。

! 操作符无法加输入。

class test {
public:
	test(int i = 0) :m_num(i) {};
	const test& operator++() {    //前++
		++m_num;
		return *this;
	}
	const test& operator++(int) {    //后++
		m_num++;
		return *this;
	}
	const test& operator--() {    //前--
		--m_num;
		return *this;
	}
    const test& operator--(int) {    //后+--
		m_num--;
		return *this;
	}
    bool operator!() {
		return true;
	}
private:
	int m_num;
};
int main() {
	test t(1);
	t++;
	++t;
    t--;
    --t;
    !t;
	return 0;
}

2.4.() [] 重载

() [] 操作符可以增加任意输入，均可以实现重载。

class test {
public:
	test(int i = 0){
		for (int j = 0; j < 10; j++) {
			m_num[j] = i+j;
		}
	};
	int operator[](int i) {
		return m_num[i];
	}
	int operator()(int i) {
		return m_num[i];
	}
	int operator()(int i,int j) {
		return m_num[i]+ m_num[j];
	}
private:
	int m_num[10];
};
int main() {
	test t(0);
	cout << t[1] << endl;
	cout << t(5) << endl;
	cout << t(5,6) << endl;
	return 0;
}

2.5.<< >> 重载

<< >> 操作的目的是，直接调用当前类，来持续的往流上输入，或者持续的从流中输出，为了保证多个流运算符的连接使用，必须使用友元的方式进行重载，并将流作为返回值。

class test {
public:
	test(int i = 0) : m_num(i) {};
	friend ostream& operator<<(ostream& os, const test& t);
	friend istream& operator>>(istream& is, test& t);
private:
	int m_num;
};
ostream& operator<<(ostream& os, const test& t) {
	os << t.m_num;
	return os;
}
istream& operator>>(istream& is, test& t) {
	int i;
	cin >> i;
	t.m_num = i;
	return is;
}
int main() {
	test t1(10);
	test t2(2);
	cout << t1 << t2;
	cin >> t1 >> t2;
	return 0;
}

2.6.-> 指针重载

-> 不允许带输入，也可以不输出指针。

class base {
public:
	void print() {
		cout << "base" << endl;
	}
};

class test {
public:
	base* operator->() {
		return m_base;
	}
private:
	base* m_base;
};
int main() {
	test t1;
	t1->print();
	return 0;
}