C++ STL 重载运算符

一天，无意中看到如下类定义:

            class Foo

            {

                    int a1;

                    int a2;

                   //方案一

                     bool operator<(const Foo& other)  const //类字典序比较方式

                    {

                            return ((a1<other.a1) || (!(other.a1<a1) && (a2<other.a2));

                    }

            }

        怪在哪呢？就怪在粗体字的部分的，看上去挺别扭的写法，不就是

            //方案二

            bool operator<(const Foo& other)  const

            {

                if(a1<other.a1 || (a1==other.a1 && a2<other.a2))

                    return true;

                return false;

            }

        这样不是更清晰？！难道是妙在少了一行代码???

       其实谜底在于，方案一只用了一个小于号，而方案二却用了小于号与等于号，多了一个等于号；更正式来说

是要多重载一个==号，例子中的a1,a2是基本类型，其==操作已默认实现，但当a1或a2为类时，就得自己重

载a1或a2的“==”运算符了。

        换言之，在a1或a2为对象时，

                方案一：只须重载小于运算符

                方案二：必须重载小于运算符以及“==”运算符

C++ STL 重载运算符(++,--)

++，--均有前缀(Prefix)，后缀(Postfix)的形式，分别如下(这时只列举为成员函数方式)，

class Foo

{

 int n;

 Foo(const Foo&  other) : n(other.n){}

  //对于 ++foo

 Foo& operator++()

{

n++;

return (*this);

}

//对于 foo++

Foo&   operator++(int)

{

         Foo* foo = new Foo(*this);

        n++;

        return (*foo);

} 

//对于 --foo

 Foo& operator--()

{

       n--;

      return (this);

}

//对于 foo--

Foo&   operator--(int)

{

         Foo* foo = new Foo(*this);

        n--;

       return (*foo);

} 

 }

        由此可见，++foo 快于 foo++  ，--foo快于foo-- ，即前缀运算效率要稍高于后缀，因为后缀运算有生成新对

象的开销^_^