在C++中,只有四种运算符不可以被重载,他们是:
- 条件运算符"? :";例如a=b>c?b:c
- 指针分量运算符 "->",例如pstcTest->nNum;
- 分量运算符".",例如stctest.nNum
- 范围解析运算符"::"
- 取大小运算符"sizeof"
举个例子来理解:
str .operation<<("1234")
str---->类型
. operation<<--->类比于 函数
("1234")--->类比于 参数列表
成员函数形式运算符重载
- 单目运算参数表中无参数,调用该函数的对象为操作数
- 双目运算参数表中有一个参数,调用该函数的对象为第一操作数,参数表中的参数为第二操作数;
- 运算符函数体会对重载的运算符的含义做出新的解释，这种解释仅仅局限于重载该运算符的类之中,脱离类对象,该运算符具有系统预定义的含义
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter() {
m_nValue = 0;
};
void operator++() { //1th
if (m_nValue<65535)
{
m_nValue++;
}
}
int operator*() { //2th
return m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA;
++objA; //隐式 ;调用1th
objA.operator++();//显示,调用1th
cout << *objA << endl; //调用2处函数
return 0;
}
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter(int nNum) {
m_nValue = nNum;
};
void operator+(CCounter &obj) { //1th
m_nValue+= obj.m_nValue;
}
int operator*() { //2th
return m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA(5),objB(5);
objA+objB; //隐式,调用1th
objA.operator+(objB);//显示,调用1th
cout << *objA << endl; //调用2处函数
return 0;
}
输出:
15
稍微做了个小改动:
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter(int nNum) {
m_nValue = nNum;
};
void operator+(CCounter &obj) { //1th
m_nValue+= obj.m_nValue;
}
int operator*() { //2th
return m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA(5),objB(8); //此处变成了8
objA+objB; //隐式,调用1th
objA.operator+(objB);//显示,调用1th
cout << *objA << endl; //调用2处函数
return 0;
}
输出:
21
友元函数形式的运算符重载:
单目:
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter() {
m_nValue = 0;
};
friend void operator++(CCounter &obj) { //1th 由于友元函数不属于此类,故这里要加引用符号
if (obj.m_nValue < 65535)
{
obj.m_nValue++;
}
}
int operator*() { //2th
return m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA;
++objA; //隐式，调用1th
operator++(objA);//显示调用1th,这里需要加objA,这里与1th处与成员函数运算符重载不同!!!
cout << *objA << endl; //调用2th处函数
return 0;
}
输出:2
双目
// 运算符重载(友元函数双目).cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter(int nNum) {
m_nValue = nNum;
};
friend void operator+(CCounter &objA,CCounter objB) { //1th 由于友元函数不属于此类,故这里要加引用符号
//这里第二个&可以不用加!
objA.m_nValue+=objB.m_nValue;
}
friend int operator*(CCounter obj) { //2th
return obj.m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA(5),objB(6);
objA+objB; //隐式，调用1th
operator+(objA,objB);//显示调用1th,这里需要加objA,这里与1th处与成员函数运算符重载不同!!!
cout << *objA << endl; //调用2th处函数
return 0;
}
输出:
17
小改动一下:
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter(int nNum) {
m_nValue = nNum;
};
friend void operator+(CCounter &objA,CCounter objB) { //1th 由于友元函数不属于此类,故这里要加引用符号
//这里第二个&可以不用加!
objA.m_nValue+=objB.m_nValue;
}
friend int operator*(CCounter obj) { //2th
return obj.m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA(5),objB(6);
objA+objB; //隐式，调用1th
operator+(objA,objB);//显示调用1th,这里需要加objA,这里与1th处与成员函数运算符重载不同!!!
cout << *objB << endl; //调用2th处函数,这里改动为objB,此处与上面不一样
return 0;
}
输出;6
| ---- | 成员函数形式 | 友元函数形式 |
|---|---|---|
| 单目运算 | 隐式:对象#（#对象） | 隐式:对象#（#对象） |
| 单目运算 | 显示: objA(对象).operator#() | operator#(对象) |
| 双目运算 | 隐式:对象A#对象B | 隐式:对象A#对象B |
| 双目运算 | 显式:对象A.operator#(对象B) | 显式:operator#(对象A,对象B) |
特殊符号:
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter(int nNum) {
m_nValue = nNum;
}
CCounter(CCounter &obj) {
m_nValue = obj.m_nValue;
}
CCounter& operator=(CCounter &obj) { //1th
m_nValue = obj.m_nValue;
return *this;
}
int operator *() {
return m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA(15), objB(5);
objA = objB; //隐式,调用1th
cout << *objA << endl; //调用2处函数
return 0;
}
输出:
5
做个改动:
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter(int nNum) {
m_nValue = nNum;
}
CCounter(CCounter &obj) {
m_nValue = obj.m_nValue;
}
CCounter& operator=(CCounter &obj) { //1th
m_nValue = obj.m_nValue;
return *this;
}
int operator *() {
return m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA(15), objB(5);
objA = objB; //隐式,调用1th
cout << *objB << endl; //调用2处函数,这里与上面例子不同
return 0;
}
输出:5
重新做个改动:(这里需要注意)
这个例子很重要
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter(int nNum) {
m_nValue = nNum;
}
CCounter(CCounter &obj) {
m_nValue = obj.m_nValue;
}
CCounter& operator=(CCounter &obj) { //1th
m_nValue = obj.m_nValue;
return *this;
}
int operator *() {
return m_nValue;
}
private:
int m_nValue;
};
int main()
{
CCounter objA(15), objB(5);
objB = objA; //隐式,调用1th,这里是把等号右边传入重载的函数里面!!!!这里需要注意!!!!
cout << *objA << endl; //调用2处函数,这里将objA改为objB结果不变！！！！！！！
return 0;
}
输出:15
注意:
objB = objA; //隐式,调用1th,这里是把等号右边传入重载的函数里面!!!!这里需要注意!!!!
CCounter& operator=(CCounter &obj) { //1th
m_nValue = obj.m_nValue;
return *this;
}
这里要进行解释一波:
重点:
1.如果返回类型为类类型,即为CCounter,则在执行return这一句话的时候,会再次调用拷贝构造(详见https://www.jianshu.com/p/2ab932c512a7,里面谈到了调用拷贝构造的时机,从原理上来理解的话,实际上可以这么理解:
CCounter XXX(临时对象)= *this,这样的话就会调用拷贝构造,因为XXX和*this指的是两个对象(两个对象的话,肯定需要再次开辟内存空间,就会再次调用拷贝构造)；
回顾一下https://www.jianshu.com/p/2ab932c512a7(它这里没有加引用,所以肯定会调用拷贝构造):
//全局函数，传入的是对象 !!!!!
void g_Fun(CExample C) //6th
{
cout << "test,执行全局函数了" << endl;
}
而如果加了引用的话:
CCounter &XXX(临时对象)= *this,这里*this用A来代替,假设A也是类类型的一个对象,那么此时XXX和A实际上指定是同一个对象,此时就不会再开辟内存空间)
2.参数表里面why是(CCounter &obj)??
其实上面一点已经解释的很到位了,如果不加引用,必然会调用拷贝构造
加引用的效果:
CCounter &obj=objA
不加引用的效果(调用拷贝构造):
CCounter obj=objA
3.返回值为什么为*this??
this是个指针类型,而返回类型为类类型(是个对象),故要对this进行解引用！
特殊运算符二([ ])
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter() {
for (int i = 0;i<15;i++)
{
m_nValue[i] = i;
}
}
int operator [](int nCount) {
return m_nValue[nCount];
}
private:
int m_nValue[15];
};
int main()
{
CCounter objA;
for (int i =0;i<15;i++)
{
cout << objA[i] <<' ';
}
return 0;
}
输出:
image.png
特殊运算符重载：
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CCounter {
public:
CCounter() {
memset(m_szStr, 0, sizeof(m_szStr));//0th
}
friend ostream& operator<<(ostream& output,CCounter &obj) {//1th
output << obj.m_szStr;
return output;
}
friend istream& operator>>(istream& input, CCounter &obj) {//2th
input.getline(obj.m_szStr,15) ;//获取一行的数据(这里指字母或者数字的个数,包括'\0')
//输入的个数大于15,只是获取前面15个!!!
return input;
}
private:
char m_szStr[15];
};
int main()
{
CCounter obj; //调用0th处的构造函数
cin >> obj; //调用2th
cout << obj; //调用1th
return 0;
}
image.png
Input为获取的这一行的数据的个数(字母,数字,'\0')
image.png
image.png
str<<("1234")
等价于str.operation<<("1234")
