C++之类的特性使用

运算符重载

用于对常规的运算符重载，部分运算符号无法重载。

• 重载后的运算符必须含有一个用户定义的操作数，是为了防止用户失误重载了标准的运算符
• 重载运算符不能违反原有的句法规则
• 不能凭空创造新的运算符

可重载的运算符

class time
{
private:
	...
public:
	time operator+(const time &);
	time operator*(const int);
	time operator-(const time &);
};
...
time time::operator+(const time & m)
time time::operator-(const time & m)
time time::operator*(const int m)

友元函数

提供了一种除成员函数外的接口，用于访问数据。
友元分为三种：友元函数，友元类，友元成员函数。
此处主要用于介绍：非成员重载运算符函数。
运算符表达式左边的操作数对应于运算符函数的第一个参数，运算符表达式右边的操作数对应于运算符函数的第二个参数。
必须使用友元函数的时候：第一个操作数不是自身对象。例如<<和>>。

class time
{
private:
	...
public:
	friend time operator+(const time &,const time &);
}
time operator+(const time & m.const time & n)//不要加上time前缀,不属于time

重载<<运算符

#include<iostream>
using namespace std;

class complex
{
	private:
		double re;
		double im;
	public:
		complex();
		complex(double m_re,double m_im);
		complex operator +(const complex & temp)const;
		complex operator -(const complex & temp)const;
		complex operator *(const double num)const;		//数值乘法 
		complex operator *(const complex & temp)const;	//复数乘法 
		complex operator ~()const;						//单目运算符，不能加入参数 
		double show_re()const{return re;}
		double show_im()const{return im;}

		friend ostream & operator <<(ostream & os,complex & temp);	//<<重载 输出  
		friend istream & operator >>(istream & is,complex & temp);	//>>重载 输入
///
		friend complex operator *(const double num,const complex & temp);
		void set(double m_re,double m_im); 
};
int main()
{
	complex a(3.0,4.0);
	complex c;
	complex t;		//需要加入临时变量，否则会报错 
	cout<<"enter a complex number"<<endl;
	while(cin>>c)
	{
		cout<<"c is"<<c<<"\n";
		t=~c; 
		cout<<"~c is"<<t<<"\n";
		cout<<"a is"<<a<<"\n";
		t=a+c;
		cout<<"a+c is"<<t<<"\n";
		t=a-c;
		cout<<"a-c is"<<t<<"\n";
		t=a*c;
		cout<<"a*c is"<<t<<"\n";
		t=2*c;
		cout<<"2*c is"<<t<<"\n";
		cout<<"enter a complex number"<<endl;
	}
	cout<<"over";
	return 0;
}
complex:: complex()
{
	re=0;
	im=0;
}
complex::complex(double m_re,double m_im)
{
	re=m_re;
	im=m_im;
} 
complex complex:: operator +(const complex & temp)const
{
	double t_re=re+temp.show_re();
	double t_im=im+temp.show_im();
	complex t=complex(t_re,t_im);
	return t;
}
complex complex::operator -(const complex & temp)const
{
	double t_re=re-temp.show_re();
	double t_im=im-temp.show_im();
	complex t=complex(t_re,t_im);
	return t;
}
complex complex::operator *(const double num)const		//数值乘法 
{
	double t_re=re*num;
	double t_im=im*num;
	complex t=complex(t_re,t_im);
	return t;
}
complex complex::operator *(const complex & temp)const	//复数乘法 
{
	double t_re=re*temp.show_re()-im*temp.show_im();
	double t_im=im*temp.show_re()+re*temp.show_im();
	complex t=complex(t_re,t_im);
	return t;
}
complex complex::operator ~()const
{
	complex t=complex(-re,-im);
	return t;
}
void complex::set(double m_re,double m_im)
{
	re=m_re;
	im=m_im;	
}	

///
ostream & operator <<(ostream & os,complex & temp)		//<<重载 输出  
{
	if(temp.im>0)
	{
		os<<" "<<temp.show_re()<<"+"<<temp.show_im()<<"i";		
	}
	else 
	{
		os<<" "<<temp.show_re()<<""<<temp.show_im()<<"i";
	}
	return os;
}
istream & operator>>(istream & is,complex & temp)		//>>重载 输入 
{
	double t_re,t_im;
	cout<<"input the re"<<endl;
	is>>t_re;
	cout<<"inpue the im"<<endl;
	is>>t_im;
	temp.set(t_re,t_im);
	return is;
}
/
complex operator *(const double num,const complex & temp)
{
//	complex t=temp;
	return temp*num;	//注意const函数的使用 
//	complex t=complex(temp.show_re()*num,temp.show_im()*num);
//	return t;
}

用于处理乘法的顺序的例程。

#include<iostream>
using namespace std;
//重载运算符与友元函数 
class vector
{
	private:
		double x;
		double y;
	public:
		vector(double mx,double my);
		vector();
		double operator *(const vector & temp);
		void operator +(const vector & temp);
		void operator *(const int num);
		void show()const;
		double show_x()const;
		double show_y()const;
		friend vector operator *(const int num,const vector & temp);
};
int main()
{
	vector x;
	x=vector(1,1);
	cout<<"show x"<<endl;
	x.show();
	vector y;
	cout<<"y is initial"<<endl;
	y.show();
	x*3;
	x.show();
	y+x;
	y.show();
	vector z=3*y;
	z.show();
}
vector::vector()
{
	x=0;
	y=0;
}
vector::vector(double mx,double my)
{
	x=mx;
	y=my;
}
double vector::operator *(const vector & temp)
{
	double t;
	t=x*temp.show_x()+y*temp.show_y();
	return t;
}
void vector::operator +(const vector &temp)
{
	x+=temp.show_x();
	y+=temp.show_y();
}
void vector::show()const
{
	cout<<" "<<x<<",";
	cout<<y<<endl;
}
double vector::show_x()const
{
	return x;
}
double vector::show_y()const
{
	return y;
}
///数乘的顺序问题
void vector::operator *(const int num)
{
	x*=num;
	y*=num;
}
vector operator *(const int num,const vector & temp)		//此处不必再加上friend 
{
	double mx,my;
	mx=num*temp.show_x();
	my=num*temp.show_y();
	vector t;
	t=vector(mx,my);
	return t;
}

类的类型转换（自动和强制）

接受一个参数的构造函数，提供一个或多个默认值参数也可以，将实现从该参数类型到类类型的转换。

class time
{
private:
	...
public:
	explicit time(int a);//从int到time的转换,explicit意味着只能显式的类型转换

time temp;
temp=12;		//隐式
temp=time(12);	//显式
temp=(time)12;	//显式
}

一个不能指定返回类型，且不具有参数的类方法（转换函数）可实现类到标准类型（int，double）的转换。

class time
{
	private:
		int min;
		int sec;
	public:
		operator int()const;	//无返回类型，无输入参数
		operator double()const;	//无返回类型，无输入参数
}
time ::operator int()const;
{
	return int (60*min+sec);
}
time ::operator double()const;
{
	return double(60*min+sec)
}

在类型转换时，要注意防止二义性的问题。