重载递增和递减运算符

在迭代器类中通常会实现递增运算符(++)和递减运算符(--)，这两种运算符使得类可以在元素的序列中前后移动。C++语言并不要求递增和递减运算符必须是类的成员，但是因为它们改变的正好是所操作对象的状态，所以建议将其设定为成员函数。
对于内置类型来说，递增和递减运算符既有前置版本也有后置版本。同样我们也应该为类定义两个版本的递增和递减运算符。

定义递增运算符

在上面的代码中，我们首先在stone类中定义的前置递增，然后由定义了后置递增，因为这两个版本重载的是同一个符号，这就意味着重载版本所用的名字将是同一个，并且运算对象的数量和类型都相同。
这样当我们调用递增运算符的时候编译器将不知道该调用哪一个而报错。为了解决这一问题，后置版本接受一个额外的int类型的形参stone operator++ (int)。
这个形参的唯一作用就是区分前置版本和后置版本的函数，而不是真的要在实现后置版本时参与运算。

这也是递增和递减运算符重载和其他运算符重载不同的地方，这一点尤为重要。

还有要注意的是后置版本的递增，要先使用这个值，然后在进行++的操作，所以在重载后置版本的时候要在函数里定义一个临时变量，用于函数的返回。而且这里的返回类型不能是return by reference，只能return by value,因为临时变量不能return by reference。

定义递减运算符

namespace jj02 {

	class stone {       //定义一个名为stone的类
	public:
		stone() :m_long(0), m_weigh(0), m_high(0) {}
		stone(int l, int w, int h)
			:m_long(l), m_weigh(w), m_high(h) {}

		const int& weigh() const { return m_weigh; }    //获取宽度
		const int& high() const { return m_high; }     //获取高度
		const int& mlong() const { return m_long; }     //获取长度

        //前置递增运算符重载
		stone& operator++  () {
			this->m_high += 1;
			return *this;
		}

        //后置递增运算符重载
		stone operator++ (int) {
			stone temp = *this;
			++(*this).m_high;
			return temp;
		}

		stone& operator = (const stone& st) {
			m_high = st.high();
			m_long = st.mlong();
			m_weigh = st.weigh();
		}
		

	private:
		int m_long, m_weigh, m_high;
	};


	void test02() {
		std::cout << "test02........." << std::endl;
		stone s1(1, 2, 3);
		stone s2(2, 3, 4);
		auto& s3 = my_min(s1, s2);
		std::cout << "m_weigh = " << s3.weigh() << std::endl;
		stone s4 = s2++; 
		std::cout <<s4.mlong()<< s4.weigh()<< s4.high() << std::endl;
		std::cout << s2.high() << std::endl;

	} 
}
int main() {

	
	jj02::test02();
	
	return 0;
}

定义递减运算符与之相似，不再陈述。下面是参考代码：

     //前置递减运算符重载
 	stone& operator--  () {
 		this->m_high -= 1;
 		return *this;
 	}

     //后置递减运算符重载
 	stone operator++ (int) {
 		stone temp = *this;
 		--(*this).m_high;
 		return temp;
 	}

End