运算符重载(一)

c++运算符重载学习小结（一）

---

对于运算符重载的简单了解：
所谓运算符重载，就是对已有的运算符重新进行定义扩展到运算分量是对象的情况，赋予其另一种功能，以适应不同的数据类型。
运算符重载只是一种“语法上的方便”，也就是说它是另一种函数调用方式，其实运算符重载也是一种特殊的函数重载。
运算符重载实现是编译时的多态，是对已有的运算符赋予的多重含义，使得同一运算符作用于不同类型的数据时，导致不同类型的行为。

---

关于运算符重载的一些基本的性质与规则的简单理解：
1.运算符重载是一种特殊的函数重载
2.不能重载的运算符. .* :: sizeof ?:
不可被重载的运算符
+ - * / % ^
& | ~ ! , =
< > <= >= ++ –
<< >> == != && ||
+= -= /= %= ^= &=
|= *= <<= >>= [] ()
-> ->* new new[] delete delete[]
3.运算符重载的参数时固定的 即重载函数 的个数与标准运算符要保持一致
4. 标准运算符 重载函数的参数
一元运算符（前后缀） 有且只能有一个参数
二元运算符 （中缀） 有且只能有两个参数
针对类对象进行的操作 至少有一个属于class类型
5.关于运算符重载的一些限制
（1）.不能改变重载运算符的优先级和结合性
（2）.默认重载运算符不能用做参数
（3）.不能改变原有运算符的参数个数
（4）.不能创建新的运算符
（5）.并不是所有运算符都支持重载
6.运算符的重载形式有两种
一、重载为类的成员函数
二、重载为类的友元函数
7.双目运算符重载为成员函数时，左操作数是访问该重载运算符的对象本身数据，此时成员运算符函数只有一个参数，他的第一个运算对象绑定在隐式的this指针上
8.运算符成员函数的调用方法
（1）显式调用 对象名.operator运算符号（参数）
（2）隐式调用 对象名 重载的运算符号 对象名
9.单目运算符重载为成员函数时，操作数就是访问该重载运算符对象本身的数据，有this指针指出，此时成员函数没有参数
10.友元运算符函数
类体内声明 friend(返回函数) operator运算符（参数表）
类体外定义 （返回类型）operator运算符（参数表）{
函数体
}
11.有四个符号既是一元又是二元运算符：+ - * &
12.定义运算符重载时，声明为类的成员或非成员函数的情况：
（1）.赋值（=）、下标（[]）、调用（()）和成员访问箭头（->）运算符必须是成员；
（2）.复合运算符一般是成员，但并非必须；
（3）.改变对象状态或与给定类型密切相关的运算符，例如：递增、递减、解应用运算符，通常是成员；
（4）.具有对象性的运算符可能转换任意一端的运算对象，如：算术、相等性、关系和位运算符等，因此通常应该是非成员函数。
13.关于递增递减运算符前置后置重载的理解：
（1）.C++语言并不要求递增递减运算符必须是类的成员，但是因为它们改变的正好是它们所操作的对象，所以建议设定为成员函数。
（2）.为了与内置版本一致，前置运算符应该返回递增或者递减后对象的引用；后置运算符应该返回对象的原值，返回的形式是一个值而非引用。
（3）.声明运算符重载函数的区别：
前置重载：类名& operator++（–）（）；
后置重载：类名&operator–（++）（数据类型）；
14.某些运算符不应该被重载：
某些运算符指定了运算对象的求值顺序，因为重载的运算符本质上式一次函数调用，所以这些关于运算对象的求值顺序的规则无法运用到重载的运算符上，特别的，逻辑与运算符、逻辑或运算符和逗号运算符的运算对象的求值顺序规则无法保留下来，除此之外，&&和||运算符的重载版本也无法保留内置运算符的短路求值属性，两个运算对象总是会被求值。
另一个原因是：我们一般不重载逗号运算符和取地址运算符，c++语言已经定义了这两种运算符用于类类型对象时的特除含义，所以一般来说他们不应该被重载。
通常情况下，不应该被重载的是逗号，取地址，逻辑与和逻辑或运算符。
14.运算符重载的值返回与引用返回：
返回引用的好处既可以于赋值的原始语义已知，又可避免拷贝构造函数和析构函数的调用。

---

简单代码示例：

#include <iostream>
using namespace std;
class Op{
    int re,im;
public:
    Op(int r,int i):re(r),im(i){}
    Op()
    {
        re = 0;
        im = 0;
    }
    //重载为类的成员函数
    Op operator!();
    Op operator+(const Op &obj);
    //前置运算符重载 
    Op& operator++();
    Op& operator--();
    //后置运算符重载
    Op operator++(int);
    Op operator--(int);
    //重载为类的友元函数
    //重载输入输出运算符，只能用友元函数
    friend ostream &operator<<(ostream &os,const Op &c);
    friend istream &operator>>(istream &is,Op &c);

};
//此时成员运算符函数只有一个参数，它的第一个运算对象绑定在隐式的this指针上
Op Op::operator +(const Op &obj){
    Op temp;
    temp.re = re + obj.re;
    temp.im = im + obj.im;
    return temp;
}
//！重载成负号 
Op Op::operator !(){
    Op temp;
    temp.re = -re;
    temp.im = -im;
    return temp;
}
//输出运算符重载 
ostream & operator<<(ostream &os,const Op &c){
    os << c.re;
    if(c.im > 0)
        os << "+" << c.im << "i" << endl;
    else
        os << c.im << "i" << endl;
    return os;
}
//输入运算符重载 
istream & operator>>(istream &is,Op &c){
    is >> c.re >> c.im;
    return is;
}
//前置运算符重载 
Op& Op::operator++(){
    Op temp;
    temp.re=++re;
    temp.im=++im;
    return *this; 
} 
Op& Op::operator--(){
    Op temp;
    temp.re=--re;
    temp.im=--im;
    return *this; 
}
//后置运算符重载 
Op Op::operator++(int){
    Op temp;
    temp.re=re++;
    temp.im=im++;
    return *this; 
}
Op Op::operator--(int){
    Op temp;
    temp.re=re--;
    temp.im=im--;
    return *this; 
}
int main(int argc,char *argv[]){
    Op obj1(1,2),obj2(3,4);//创建对象 
    --obj1;
    ++obj2;
    obj1++;
    obj2--;
    Op obj3 = obj1 + !obj2;//重载！作为负号 
    cout<<"Output the result:";
    cout << obj3;
    cout<<"Please enter your twos numbers:";
    cin >> obj3;
    cout << obj3;
    return 0;
}