C++运算符重载总结

+       -        *       /       %      ^       &      |       ~

!        =       <       >       +=     -=      *=     /=     %

^=     &=    |=     <<     >>     >>=  <<=  ==     !=

<=     >=     &&   ||     ++     --       ->*   ‘        ->

[]      ()       new delete      new[]       delete[]

.        ::       .*      ?:      sizeof

不改变运算符的优先级

不改变运算符的结合性

不改变运算符所需要的操作数

不能创建新的运算符

class test

{

public :

    test(int _a, int _b)

    {

       a = _a;

       b = _b;

    }

    void print()

    {

       cout << "a:" << a << "," << "b:" << b << endl;

    }

    //成员函数重载，this指针可以省略

    test operator+(test&t2)

    {

       test tmp(a + t2.a, b + t2.b);

       return tmp;

    }

    //friend test operator+(test&t1, test&t2);//友元函数重载

protected:

private:

    int a;

    int b;

};

//test operator+(test&t1, test&t2)

//{

//  test tmp(t1.a + t2.a, t1.b+ t2.b);

//  return tmp;

//}

void  main()

{

    test t1(1,2);

    test t2(3, 4);

    test t3 = t1 + t2;

    t3.print();

    system("pause");

}

1、重载为成员函数，解释为：

Object . operator op ()

操作数由对象Object通过this指针隐含传递

2、重载为友员函数，解释为：

operator op (Object)

    操作数由参数表的参数Object提供

//通过成员函数完成前置--

         Test & operator--()

         {

                   this->a--;

                   this->b--;

                   return *this;

         }

         //通过成员函数完成前置--

         Test & operator++()

         {

                   this->a++;

                   this->b++;

                   return *this;

         }

         //通过类成员函数完成后置--

         Test  operator--(int)

         {

                   Complex tmp = *this;

                   this->a--;

                   this->b--;

                   return tmp;

         }

         //通过类成员函数完成后置--

         Test  operator++(int)

         {

                   Complex tmp = *this;

                   this->a++;

                   this->b++;

                   return tmp;

1、重载为成员函数，解释为：

ObjectL . operator op ( ObjectR )

左操作数由ObjectL通过this指针传递，右操作数由参数ObjectR传递

2、重载为友员函数，解释为：

operator op ( ObjectL, ObjectR )

  左右操作数都由参数传递

//通过类成员函数完成-操作符重载

         Test operator-(Complex &c2)

         {

                   Complex tmp(a - c2.a, this->b - c2.b);

                   return tmp;

         }

         Test operator+(Complex &c2)

         {

                   Complex tmp(a + c2.a, this->b + c2.b);

                   return tmp;

         }