C++——运算符重载

不可重载的运算符

. .* :: ?: sizeof

重载运算符的规则

1. 不改变运算符的优先级
2. 不改变运算符的结合性
3. 不改变运算符所需要的操作数
4. 不能创建新的运算符，只有系统预定义的运算符才能被重载

重载运算符的格式

类型 类名：：operator op(参数){
	//相对于该类定义的操作
}

用成员重载运算符（有this指针）

//类的定义
class TriCoor{
	public:
		TriCoor(int mx=0,int my=0,int mz=0);
		TriCoor operator+(TriCoor t);
		TriCoor &operator++();
		TriCoor &operator=(TriCoor t);
		void show();
		void assign(int mx,int my,int mz);
	private:
		int x,y,z;
}

//用成员函数完成重载
TriCoor TriCoor::operator+(TriCoor t){
	TroCoor temp;
	temp.x=x+t.x;
	temp.y=y+t.y;
	temp.z=y+t.z;
	return temp;
}

TriCoor &TriCoor::operator++(){
	x++;
	y++;
	z++;
	return *this;
}

TriCoor &TriCoor::operator=(TriCoor t){
	x=t.x;
	y=t.y;
	z=t.z;
	return *this;
}

用友元函数完成重载（无this指针）

1. 用友元函数重载运算符，左右操作数都由参数传递；
2. C++中不能用友元函数重载的运算符有： = （） [] ->

//类的定义
class complex{
	public:
		Complex(double r=0,double i=0);
		Complex(int a){Real=a;Image=0;}
		friend Complex operator+(const Complex&c1,const Complex&c2);
		friend Complex operator-(const Complex&c1,const Complex&c2);
		friend Complex operator-(const Complex&c);
	private:
		douoble Real,Image;
};

Complex::Complex(double r,double i){
	Real=r;
	Image=i;
}

Complex operator+(const Complex&c1,const Complex&c2)z{
	double r=c1.Real+c2.Real;
	double i=c1.Image+c2.Image;
	return Complex(r,i);
}

Complex operator-(const Complex&c1,const Complex&c2)z{
	double r=c1.Real-c2.Real;
	double i=c1.Image-c2.Image;
	return Complex(r,i);
}

Complex operator-(const Complex&c){
	return Complex(-c.Real,-c.Image);
}

重载赋值运算符

//类定义
class Name{
	public:
		Name(char *pN="\0");
		Name(const Name&);
		Name &operator=(Name);
		~Name();
	protected:
		char *pName;
		int size;
};

//赋值运算符重载
Name &Name::operator=(Name Obj){
	delete[] pName;
	size=Obj.size;
	pName=new char[size+1];
	if(pName!=0)
		strcpy_s(pName,size+1,Obj.pName);
	return *this;
}

重载运算符[]和（）

//类定义
class Vector{
	public:
		Vector(int size=1);
		~Vector();
		int & operator[](int i)const;
		int operator()()const;
	private:
		int *v;
		int len;
};

int &Vector::operator[](int i)const{
	if(i>=0&&i<len)	
		return v[i];
	else
		cout<<"outside!"<<endl;
	exit(0);
}

int Vector::operator()()const{
	return len；
}

重载流插入和流提取运算符

//输出向量
ostream &operator<<(ostream& output,const Vector&A){
	for(int i=0;i<A.len;i++)
		output<<A.v[i]<<" ";
	return output;
}
//输入向量
istream &operator>>(istream& inpur,Vector & A){
	for(int i=0;i<A();i++)
		input>>A.v[i];
	return input;
}

类类型转换

//简单串类与字符串之间的类型转换
class String{
		char *data;
		int size;
	public:
		String(char *s){
			size=strlen(s);
			data=new char(size+1);
			strcpy_s(data,size+1,s);
		}
		operator char*()const //类型转换
		{	return data;	}
};

void main(){
	String sobj="hell";
	char *svar=sobj;//类型转换
	cout<<svar<<endl;
}