运算符重载示例

1.为什么需要运算符重载？

当我们需要操作对象的时候，例如实现对象相加，直接相加是不允许的，必须使用运算符重载才能使用。

2.运算符重载的格式？

返回类型 operator 运算符（参数）{}

3.哪些运算符不能重载？

.成员使用

.*成员指针使用

::域说明

sizeof

?:三目运算符

4.运算符重载出现的地方

a.成员函数

b.友元函数

5.运算符使用规则

（1）不能自己造新的运算符

（2）不改变运算符的优先级

（3）成员函数，且双目运算符。

（4）运算符重载在类内的条件是：函数的第一个参数必须是对象，且第一个参数必须要不写，除此之外都放在类外。

（5）友元函数，不可以省略参数。什么情况需要些友元：运算符重载在类外定义，当要用到类内的成员变量，成员变量是私有的，要写友元。

（6）重载后操作尽量和运算符原来含义一致

6.运算符重载的调用过程

运算符重载是不需要调用的，当你使用到对象运算会自动触发。运算符重载可以不要返回值，里面可以直接写输出，当最好不要这样。

7.运算符重载示例

（1）操作>=的运算

类外：

class CStu

{

public:

int nAge;

CStu(int age)

{

nAge = age;

}

};

int operator >= (CStu& st1,CStu& st2)

{

return (st1.nAge >= st2.nAge);

}

int main()

{

CStu st1(12);

CStu st2(13);

cout << (st1 >= st2) << endl;

return 0;

}

类内：

class CStu
{
public:
int nAge;


CStu(int age)
{
nAge = age;
}
int operator >= (CStu& st2)  //第一个参数不需要写，默认的对象
{
return (nAge >= st2.nAge); 
}
};

（2）操作&运算符

class CStu
{
public:
int nAge;


CStu(int age)
{
nAge = age;
}
};


int operator & (CStu& st1,CStu& st2)  
{
return (st1.nAge & st2.nAge);  


int main()
{
CStu st1(12);
CStu st2(13);


cout << (st1 & st2) << endl; 
return 0;
}

（3）操作-运算符

类外：
class CStu
{
public:
int nAge;


CStu(int age)
{
nAge = age;
}
};
int operator-(CStu& st)
{
return (-st.nAge);
}
int main()
{
CStu st1(14);


cout << (-st1) << endl;  //-14
return 0;
}
类内：
class CStu
{
public:
int nAge;


CStu(int age)
{
nAge = age;
}
int operator-()
{
return (-nAge);
}
};

（4）输出运算符

class CStu
{
public:
int nAge;


CStu()
{
nAge = 12;
}
};
ostream& operator << (ostream& os,const CStu& st) 
{
os << st.nAge;
return os;
}


int main()
{
CStu st;


cout << st << st;
return 0;
}

（5）输入运算符

class CStu
{
public:
int nAge;


CStu()
{
nAge = 12;
}
void show()
{
cout << nAge << endl;
}
};
istream& operator >> (istream& ist,CStu& st) 
{
ist >> st.nAge;
return ist;
}


int main()
{
CStu st;
cin>>st;
st.show();
return 0;
}

（6）+=运算符重载

class CStu
{
public:
int nAge;
double dbheight;


CStu()
{
nAge = 0;
dbheight = 0.0;
}

};
CStu& operator+=(CStu& st1,int a)  
{
st1.nAge =st1.nAge+a; //原本的运算逻辑
return st1; //返回值可以连续运算
}
int main()
{
CStu st;
st += a += 113;  //结合性从右向左 
cout << st.nAge;
return 0;
}

（7）前++运算符

类外
class CStu
{
public:
int  nAge;
CStu()
{
nAge = 12;
}

};


int operator++(CStu& st)
{
return (++st.nAge);
}


int main()
{
CStu st;
cout << ++st;
return 0;
}
类内
int operator++()
{
return (++nAge);
}

（8）后++运算符

class CStu
{
public:
int  nAge;
CStu()
{
nAge = 12;
}
};
int operator++(CStu& st,int n) //int n理解成一个标记
{
n = st.nAge; //记录自加前的值
st.nAge += 1;
return n; //返回自加前的值
}


int main()
{
//int a=12;b=a++ b==12 a==13
CStu st;
cout << st++;
return 0;
}


类内：
int operator++(CStu& st,int n) //int n理解成一个标记
{
n = nAge; //记录自加前的值
nAge += 1;
return n; //返回自加前的值
}