运算符重载

1.+重载

#include<iostream>  
using namespace std;  
class Brass  
{  
	int length;  
public:  
	Brass(int _length=0):length(_length){}  
	Brass(Brass& brass)
	{
		length=brass.length;
	}
	Brass operator+(Brass& brass)//基类普通重载----#1  
	{  
		return Brass(length+brass.length);  
	}  

	//改变length的值，即length+n  
	Brass operator+(int n)//基类普通重载-----#2   
	{  
		return Brass(length+n);  
	}  

	friend Brass operator+(int n,Brass& brass)//基类友元重载------#3  
	{  
		return Brass(n+brass.length);  
	}  
	virtual void show(){cout<<length;}
};  
class BrassPlus:public Brass
{
	int width;
public:
	BrassPlus(int _length=0,int _width=0):Brass(_length),width(_width){}
	BrassPlus(Brass& brass,int _width=0):Brass(brass),width(_width){}

	friend BrassPlus operator+(BrassPlus& brassplus,int n)//派生类友元重载
	{
		Brass brass=(Brass&)brassplus+n;//强制转换去掉后会进入函数自己的死循环
		//这里的强制转换是引用，而不是(Brass)brassplus，
		//这样可以在函数无意修改值得话，brassplus的值也会随之改变
		return BrassPlus(brass,n+brassplus.width);
	}
	virtual void show(){Brass::show();cout<<" "<<width<<endl;}
};
int main()  
{  
	//测试基类
	Brass one;  
	Brass two;  
	Brass add;  
	int n=2;  

	add=one+two;//use Brass operator+(Brass& brass)  

	add=one+n;//use Brass operator+(int n)如果#3的代码没写，那么add=n+one；这样的写法就是错的  

	add=n+one;//use friend Brass operator+(int n,Brass& brass)  

	//如果要为类重载运算符，并将非类的项作为第一个操作数，则可以用友元函数来反转操作数的顺序。  
	//就像#2和#3的搭配  

	//测试派生类
	BrassPlus bone;
	BrassPlus btwo=bone+2;
	btwo.show();//--->2 2
	return 0;  
}  

2.<<重载

<<的重载只能用友元函数。为什么呢？因为假如是这样的语句，cout<<brass;

第一个操作数是cout,即ostream类对象

如果使用普通的成员函数来重载，那么第一个操作数就一定是Brass类对象。

#include<iostream>  
using namespace std;  
class Brass  
{  
	int length;  
public:  
	Brass(int _length=0):length(_length){}  
	Brass(Brass& brass)
	{
		length=brass.length;
	}
	friend ostream& operator<<(ostream& os,Brass& brass)//基类友元重载
	{
		os<<brass.length;
		return os;
	}
};  
class BrassPlus:public Brass
{
	int width;
public:
	BrassPlus(int _length=0,int _width=0):Brass(_length),width(_width){}
	BrassPlus(Brass& brass,int _width=0):Brass(brass),width(_width){}

	friend ostream& operator<<(ostream& os,BrassPlus& brassplus)//派生类友元重载
	{
		os<<(Brass&)brassplus<<" ";
		os<<brassplus.width<<endl;
		return os;
	}
};
int main()  
{  
	Brass one(21);
	cout<<one<<endl;//-->21

	BrassPlus bone(21,2121);
	cout<<bone<<endl;//-->21 2121

	/*
	由于友元函数并非类成员，因此不能继承。然而您可能希望派生类的友元函数可以使用基类的
	友元函数。为此，可以通过强制类型转换实现。
	*/
	return 0;  
}  

3.负号-重载，减号的重载和加号的重载一样，不作讲述

#include<iostream>
using namespace std;
class Brass
{
	int length;
public:
	Brass(int _length=0):length(_length){}
	Brass operator-();//符号重载
	friend ostream& operator<<(ostream& os, Brass& brass);
};

Brass Brass::operator-()
{
	return Brass(-length);
}

ostream& operator<<(ostream& os, Brass& brass)
{
	os << brass.length << endl;
	return os;
}
int main()
{
	Brass one(5);
	one = -one;
	cout << one;//---->-5
	return 0;
}

4.[ ]重载

#define _CRT_SECURE_NO_DEPRECATE
//#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
#include<iostream> 
#include<string>

using namespace std;

class String
{
	char *str;
	int length;

public:
	String(char *_str = "null", int _length = 4):length(_length)
	{
		str = new char[5];
		strcpy(str, _str);
	}
	char &operator[](int i)
	{
		return str[i];
	}
};
int main()
{
	String one("ZhangSan", 8);
	cout << one[0] << endl;//Z
	cout << one[2] << endl;//a
	return 0;
}

5.=重载（主要是深度复制方面）

#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1  
#include<iostream>
#include<string.h>
using namespace std;
class Base
{
	char *ch;
public:
	Base(char *_ch = "null")
	{
		ch = new char[strlen(_ch) + 1];
		strcpy(ch, _ch);
	}
	virtual ~Base()
	{
		delete []ch;
	}
	Base & operator=(const Base & base)
	{
		if (this == &base)
			return *this;
		delete[]ch;
		ch = new char[strlen(base.ch) + 1];
		strcpy(ch, base.ch);
		return *this;
	}
};
class BasePlus :public Base
{
	char *s;
public:
	BasePlus(char *_ch = "null", char *_s = "null"):Base(_ch)
	{
		s = new char[strlen(_s) + 1];
		strcpy(s, _s);
	}
	virtual ~BasePlus()
	{
		delete []s;
	}
	BasePlus & operator=(const BasePlus& basePlus)
	{
		if (this == &basePlus)
			return *this;
		Base::operator=(basePlus);
		delete[]s;
		s = new char[strlen(basePlus.s) + 1];
		strcpy(s, basePlus.s);
		return *this;
	}
};
int main()
{


	return 0;
}

6.++重载

#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1  
#include<iostream>

using namespace std;
class Base
{
	int length;
public:

	Base(int _length=0):length(_length){}

	Base& operator++()//前自加
	{
		length += 1;//自加多少由自己决定,由此可见C++重载的大大优势
		return *this;
	}

	Base operator++(int)//后自加
	{
		Base temp(*this);
		++(*this);
		return temp;
	}

	friend ostream& operator<<( ostream &os, const Base &base)
	{
		os << base.length << endl;
		return os;
	}
};


int main()
{
	Base one;
	cout << one;//0
	cout << one++;//0
	cout << one;//1
	return 0;
}

7.>>和getline重载

#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1  

#include<iostream>
#include<string>

using namespace std;

class Student
{
	string name;
public:
	Student(string _name = "null") :name(_name) {}
	friend istream & operator>>(istream & is, Student & student)
	{
		is >> student.name;
		return is;
	}
	friend istream & getline(istream & is, Student & student)
	{
		getline(is, student.name);
		return is;
	}
	friend ostream & operator<<(ostream & os, Student & student)
	{
		os << student.name << endl;
		return os;
	}
};
int main()
{
	Student one;
	Student two;

	cin >> one;//lisan
	cout << one;//lisan

	char x = getchar();//吃掉换行符，不然下面的语句没有作用

	getline(cin, two);//li san
	cout << two;//li san
	return 0;
}