算法操作符和关系操作符

类设计如下：

class sales_item
{
public:
	friend istream& operator>>(istream&, sales_item&);
	friend ostream& operator<<(ostream&, const sales_item&);
	friend sales_item operator+(const sales_item& sale1, const sales_item &sale2);
	friend inline bool operator==(const sales_item&, const sales_item&); 
	friend inline bool operator!=(const sales_item&, const sales_item&); 
	friend inline bool operator<(const sales_item&, const sales_item&);

	//explicit sales_item(void); // 防止隐式转换
	sales_item(void) /*const*/;  //构造函数不能声明为const，默认构造函数
	~sales_item(void);

	sales_item(istream &is);
	sales_item(const string & book); //const可以避免形参被修改，引用可以避免复制实参
	sales_item(const sales_item &org); //复制构造函数
	
	//sales_item operator**(const sales_item &org); //error 不能通过连接其他合法操作符来创建任何新的操作符	
	//sales_item operator+(const int a, const int b); //error 必须至少提供一个类类型
	//sales_item operator+(const int b = 0); //error 不能有默认实参
	//sales_item operator+(const int b); //ok 默认this为类类型
	
	sales_item& operator=( const sales_item& );	
	sales_item& operator=( const string& );	//=可以重载
	sales_item& operator+=( const sales_item& );

	string GetISBN() const { return isbn; }
	int GetUnitsSold() const { return units_sold; }
	double GetRevenue() const { return revenue; }

	inline double avg_price() const; //这里声明为inline，定义处不必再声明
	bool same_ishn(const sales_item & rhs) const;	
	
private:
	string isbn;
	int units_sold;
	double revenue;
};
//非成员函数重载运算符
istream& operator>>(istream&, sales_item&); //输入
ostream& operator<<(ostream&, const sales_item&); //输出
sales_item operator+(const sales_item&, const sales_item&); //返回值不是引用，不能成为左值，也不能进行连加，如a+b+c
inline bool operator==(const sales_item&, const sales_item&); 
inline bool operator!=(const sales_item&, const sales_item&); 
inline bool operator<(const sales_item&, const sales_item&);

算术操作符

这里先看+操作符

sales_item operator+(const sales_item& sale1, const sales_item &sale2)
{
	sales_item rhs(sale1);
	rhs += sale2;
	return rhs;
}

这里只是字符串的连接，而且返回的不是引用，主要是为了内置操作符保持一致。一般定义了+，通常还要定义+=（这里+就是调用+=），复合赋值操作符通常定义为类的成员，如下

//操作符 +=
sales_item& sales_item::operator+=(const sales_item& item)
{
	isbn += item.isbn; //isbn:左操作数this->isbn
	units_sold += item.units_sold;
	revenue += item.revenue;
	return *this;
}

这样定义了+=之后，其实我们的+就可以直接调用类成员+=操作符，而不用再具体实现。

关系操作符

这里先看下相等操作符

bool operator==(const sales_item& sale1, const sales_item &sale2)
{
	return ((sale1.units_sold == sale2.units_sold) &&
		(sale1.revenue == sale2.revenue) && sale1.same_ishn(sale2));
}

主要是判定内置成员是否相等，定义了==也就要定义!=操作符了，如下

bool operator!=(const sales_item& sale1, const sales_item &sale2)
{
	return !(sale1 == sale2);
}

这里就是调用相等操作符

赋值操作符

1）赋值操作符可以重载，无论形参为何种类型，赋值操作必须定义为成员函数

	sales_item& operator=( const sales_item& );	
	sales_item& operator=( const string& );	//=可以重载

2）赋值必须返回对*this的引用，主要与内置类型一致，返回值是左操作数的引用。

sales_item& sales_item::operator=(const sales_item &item)
{
	isbn = item.isbn;
	units_sold = item.units_sold;
	revenue = item.revenue;
	return *this;
}


sales_item& sales_item::operator=(const string& str)
{
	isbn = str;
	units_sold = 0;
	revenue = 0;
	return *this;
}

这些之前就不再阐述，下面看

	sales0 = "hello sales_item"; //ok 重载形参为string类型的赋值操作符
	sales0 = 1; //error 未定义
	sales_item item5 = "sales"; //构造函数	

如下进项调试第二个就不行，因为默认没有定义int型形参的赋值操作符，第一个就可以，我们定义了形参为string的赋值操作符函数，第三个主要是为了区分，第三个其实应该调用形参为string类型的构造函数去初始化。