一:运算符重载的限制

(一)可以重载的运算符:

+    -   *    /     %      ^     &    |    ~
!    =   <   >    +=    -=   *=   /= %=
^=   &= |=   <<   >>    <<=   >>=  == !=
<=   >= &&   ||   ++    --   ,   ->* ->
()  []   new new[] delete delete[]

(二)不允许重载的运算符:

长度运算符sizeof
三目运算符: ?:
成员选择符.
域解析运算符::
成员指针.*

(三)原有基本语义不变

1.不改变运算符的优先级

运算符
描述
例子
可重载性
第一级别
     
::
作用域解析符
Class::age = 2;
不可重载
第二级别
     
()
函数调用
isdigit('1')
可重载
()
成员初始化
c_tor(int x, int y) : _x(x), _y(y*10){};
可重载
[]
数组数据获取
array[4] = 2;
可重载
->
指针型成员调用
ptr->age = 34;
可重载
.
对象型成员调用
obj.age = 34;
不可重载
++
后自增运算符
for( int i = 0; i < 10; i++ ) cout << i;
可重载
--
后自减运算符
for( int i = 10; i > 0; i-- ) cout << i;
可重载
const_cast
特殊属性转换
const_cast<type_to>(type_from);
不可重载
dynamic_cast
特殊属性转换
dynamic_cast<type_to>(type_from);
不可重载
static_cast
特殊属性转换
static_cast<type_to>(type_from);
不可重载
reinterpret_cast
特殊属性转换
reinterpret_cast<type_to>(type_from);
不可重载
typeid
对象类型符
cout &laquo; typeid(var).name();
cout &laquo; typeid(type).name();
不可重载
第三级别(具有右结合性)
     
!
逻辑取反
if( !done ) …
可重载
not
! 的另一种表达
   
~
按位取反
flags = ~flags;
可重载
compl
~的另一种表达
   
++
预自增运算符
for( i = 0; i < 10; ++i ) cout << i;
可重载
--
预自减运算符
for( i = 10; i > 0; --i ) cout << i;
可重载
-
负号
int i = -1;
可重载
+
正号
int i = +1;
可重载
*
指针取值
int data = *intPtr;
可重载
&
值取指针
int *intPtr = &data;
可重载
new
动态元素内存分配
long *pVar = new long;
MyClass *ptr = new MyClass(args);
可重载
new []
动态数组内存分配
long *array = new long[n];
可重载
delete
动态析构元素内存
delete pVar;
可重载
delete []
动态析构数组内存
delete [] array;
可重载
(type)
强制类型转换
int i = (int) floatNum;
可重载
sizeof
返回类型内存
int size = sizeof floatNum;
int size = sizeof(float);
不可重载
第四级别
     
->*
类指针成员引用
ptr->*var = 24;
可重载
.*
类对象成员引用
obj.*var = 24;
不可重载
第五级别
     
*
乘法
int i = 2 * 4;
可重载
/
除法
float f = 10.0 / 3.0;
可重载
%
取余数(模运算)
int rem = 4 % 3;
可重载
第六级别
     
+
加法
int i = 2 + 3;
可重载
-
减法
int i = 5 - 1;
可重载
第七级别
     
<<
位左移
int flags = 33 << 1;
可重载
>>
位右移
int flags = 33 >> 1;
可重载
第八级别
     
<
小于
if( i < 42 ) …
可重载
<=
小于等于
if( i <= 42 ) ...
可重载
>
大于
if( i > 42 ) …
可重载
>=
大于等于
if( i >= 42 ) ...
可重载
第九级别
     
==
恒等于
if( i == 42 ) ...
可重载
eq
== 的另一种表达
   
!=
不等于
if( i != 42 ) …
可重载
not_eq
!=的另一种表达
   
第十级别
     
&
位且运算
flags = flags & 42;
可重载
bitand
&的另一种表达
   
第十一级别
     
^
位异或运算
flags = flags ^ 42;
可重载
xor
^的另一种表达
   
第十二级别
     
|
位或运算
flags = flags | 42;
可重载
bitor
|的另一种表达
   
第十三级别
     
&&
逻辑且运算
if( conditionA && conditionB ) …
可重载
and
&&的另一种表达
   
第十四级别
     
||
逻辑或运算
if( conditionA || conditionB ) ...
可重载
or
||的另一种表达
   
第十五级别(具有右结合性)
     
? :
条件运算符
int i = (a > b) ? a : b;
不可重载
第十六级别(具有右结合性)
     
=
赋值
int a = b;
可重载
+=
加赋值运算
a += 3;
可重载
-=
减赋值运算
b -= 4;
可重载
*=
乘赋值运算
a *= 5;
可重载
/=
除赋值运算
a /= 2;
可重载
%=
模赋值运算
a %= 3;
可重载
&=
位且赋值运算
flags &= new_flags;
可重载
and_eq
&= 的另一种表达
   
^=
位异或赋值运算
flags ^= new_flags;
可重载
xor_eq
^=的另一种表达
   
|=
位或赋值运算
flags |= new_flags;
可重载
or_eq
|=的另一种表达
   
<<=
位左移赋值运算
flags <<= 2;
可重载
>>=
位右移赋值运算
flags >>= 2;
可重载
第十七级别
     
throw
异常抛出
throw EClass(“Message”);
不可重载
第十八级别
     
,
逗号分隔符
for( i = 0, j = 0; i < 10; i++, j++ ) …
可重载

2.不改变运算符的结合性

例如:=结合性是从右向左
a=b=;
先执行b=,再执行a=b

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

+-*/等需要两个操作数
++ --等一个操作数
.....

4.不能创建新的运算符

二:运算符重载两种方法(传参方式不同,实现代码不同,应用场合不同)

(一)成员函数进行运算符重载(有this指针,所以传参少一个)

class A
{
private:
int op;
public:
A(int a1) :op(a1)
{
} A& operator+(const A& a) //二元运算符,第一数为this对象,第二个是a对象
{
A nonObj(this->op + a.op);
return nonObj; //返回匿名对象
}
void getInfo()
{
cout << "op:" << op << endl;
}
}; void main()
{
A a1();
A a2();
A a3 = a1 + a2;
a3.getInfo();
system("pause");
}
或者A& A::operator+(const A& a){}

(二)友元函数进行运算符重载(无this指针)

class A
{
friend A& operator+(const A& a, const A& b);  //补充:默认访问修饰符为private
private:
int op;
public:
A(int a1) :op(a1)
{
} void getInfo()
{
cout << "op:" << op << endl;
}
}; A& operator+(const A& a, const A& b) //私有是对于类,友元函数可以使用类的所有成员,不管访问修饰符
{
A nonObj(a.op + b.op);
return nonObj;
}
void main()
{
A a1();
A a2();
A a3 = a1 + a2;
a3.getInfo();
system("pause");
}

(三)上面实现的是二元运算符重载,这里来实现一元运算符重载(区分符号前置后置)

友元函数和成员函数操作运算符需要区分前置和后置(符号前后置)
前置 operator++()
++a
后置 operator++(int) //int进行占位区分 后面多一个,为后置
a++
class A
{
friend A& operator++(const A& a);
private:
int op;
public:
A(int a1) :op(a1)
{
} A& operator--() //无伪参数占位,是前置--a
{
this->op--;
A nonObj(this->op);
return nonObj;
} A& operator--(int) //使用int伪参数占位,为后置a--
{
A nonObj(this->op);
this->op--;
return nonObj;
} void getInfo()
{
cout << "op:" << op << endl;
}
}; void main()
{
A a1();
A a2();
cout << "a1";
a1.getInfo();
A a4 = a1--;
cout << "a4";
a4.getInfo();
cout << "a1";
a1.getInfo(); cout <<"--------"<< endl; cout << "a2";
a2.getInfo();
A a5 = --a2;
cout << "a5";
a5.getInfo();
cout << "a2";
a2.getInfo(); system("pause");
}

成员函数重载操作符(前置后置区分)

class A
{
friend A& operator++(A& a);
friend A& operator++(A& a,int);
private:
int op;
public:
A(int a1) :op(a1)
{
} void getInfo()
{
cout << "op:" << op << endl;
}
}; A& operator++(A& a) //对于一目运算符不能设置为const,因为要对自己进行修改
{
a.op++;
A nonObj(a.op);
return nonObj;
} A& operator++(A& a, int)
{
A nonObj(a.op);
a.op++;
return nonObj;
} void main()
{
A a1();
A a2();
cout << "a1";
a1.getInfo();
A a4 = a1++;
cout << "a4";
a4.getInfo();
cout << "a1";
a1.getInfo(); cout <<"--------"<< endl; cout << "a2";
a2.getInfo();
A a5 = ++a2;
cout << "a5";
a5.getInfo();
cout << "a2";
a2.getInfo(); system("pause");
}

友元函数重载操作符(前置后置区别)

三:运算符重载应用场景

(一)友元函数和成员函数选择方法

1.当无法修改左操作数的类是,使用全局友元函数进行重载

对<<或者>>重载
cout<<数
cin>>数
左操作都是ostream或者istream无法修改的类,
所以重载<<或者>>只能用全局友元函数

2.=,[],(),->操作符只能使用成员函数进行重载

(二)使用友元函数方法实现<<和>>操作符重载

注意:

<<返回ostream类型
cout<<a<<b //连续输出a b两个变量
>>返回istream类型
cin>>a>>b; //连续输入两个变量到a b

实现:

class A
{
friend ostream& operator<<(ostream& out, A& a);
friend istream& operator>>(istream& in, A& a);
private:
int op;
public:
A(int a1) :op(a1)
{
} void getInfo()
{
cout << "op:" << op << endl;
}
}; ostream& operator<<(ostream& out, A& a)
{
out <<"overload<<:"<< a.op << endl;
return out;
} istream& operator>>(istream& in, A& a)
{
in >> a.op;
return in;
}
void main()
{
A a();
cout << a; cin >> a;
cout << a; system("pause");
}

(三)使用成员函数方法实现=,数组下标运算符[],函数调用符(),操作符重载

1.=和[]

class A
{
friend ostream& operator<<(ostream& out, A& a);
friend istream& operator>>(istream& in, A& a);
private:
int op;
int *pArr;
public:
A(int a1) :op(a1)
{
pArr = (int *)malloc(sizeof(int)*a1);
for (int i = ; i < a1;i++)
{
pArr[i] = i+;
}
} void getInfo()
{
cout << "op:" << op << endl;
} //赋值运算符
A& operator=(const A& a1)
{
cout << "operator=" << endl;
A nonObj(this->op + a1.op);
return nonObj;
} //数组下标运算符
int& operator[](int i)
{
cout << "operator[]" << endl;
return this->pArr[i];
}
~A()
{
if (this->pArr != NULL)
free(this->pArr);
}
}; ostream& operator<<(ostream& out, A& a)
{
out <<"overload<<:"<< a.op << endl;
return out;
} istream& operator>>(istream& in, A& a)
{
in >> a.op;
return in;
} void main()
{
A a();
//A b = a; 是错误的,不会调用=重载操作符,是初始化操作
A b();
b = a; //会调用=重载运算符
cout << a[]; system("pause");
}

2.函数调用符():用于函数调用,实现数学函数的抽象

class Func
{
public:
double operator()(double x, double y); //第一个()是重载的符号
}; double Func::operator()(double x, double y)
{
return x*x + y*y;
} void main()
{
Func func; //调用默认构造函数
double ret = func(3.0, 4.0);
cout << ret << endl;
system("pause");
}

(四)&&和||虽然可以实现重载,但是由于重载后我们无法实现短路规则(还是要靠&& ||),所以最好不要重载

C++回顾day02---<运算符重载>的更多相关文章

  1. c++入门之—运算符重载和友元函数

    运算符重载的意义是:将常见的运算符重载出其他的含义:比如将*重载出指针的含义,将<<与cout联合使用重载出输出的含义,但需要认识到的问题是:运算符的重载:本质仍然是成员函数,即你可以认为 ...

  2. Swift教程之运算符重载

    http://blog.csdn.net/mengxiangyue/article/details/43437797 原文地址:http://www.raywenderlich.com/80818/o ...

  3. C++ 运算符重载时,将运算符两边对象交换问题.

    在C++进行运算符重载时, 一般来讲,运算符两边的对象的顺序是不能交换的. 比如下面的例子: #include <iostream> using namespace std; class ...

  4. C#高级编程笔记2016年10月12日 运算符重载

    1.运算符重载:运算符重重载的关键是在对象上不能总是只调用方法或属性,有时还需要做一些其他工作,例如,对数值进行相加.相乘或逻辑操作等.例如,语句if(a==b).对于类,这个语句在默认状态下会比较引 ...

  5. C++运算符重载

    C++运算符重载 基本知识 重载的运算符是具有特殊名字的函数,他们的名字由关键字operator和其后要定义的运算符号共同组成. 运算符可以重载为成员函数和非成员函数.当一个重载的运算符是成员函数时, ...

  6. 标准C++之运算符重载和虚表指针

    1 -> *运算符重载 //autoptr.cpp     #include<iostream> #include<string> using namespace std ...

  7. python运算符重载

    python运算符重载就是在解释器使用对象内置操作前,拦截该操作,使用自己写的重载方法. 重载方法:__init__为构造函数,__sub__为减法表达式 class Number: def __in ...

  8. PoEduo - C++阶段班【Po学校】-Lesson03-5_运算符重载- 第7天

    PoEduo - Lesson03-5_运算符重载- 第7天 复习前面的知识点 空类会自动生成哪些默认函数 6个默认函数    1  构造  2  析构   3  赋值  4 拷贝构造  5 oper ...

  9. 不可或缺 Windows Native (24) - C++: 运算符重载, 自定义类型转换

    [源码下载] 不可或缺 Windows Native (24) - C++: 运算符重载, 自定义类型转换 作者:webabcd 介绍不可或缺 Windows Native 之 C++ 运算符重载 自 ...

  10. 我的c++学习(8)运算符重载和友元

    运算符的重载,实际是一种特殊的函数重载,必须定义一个函数,并告诉C++编译器,当遇到该运算符时就调用此函数来行使运算符功能.这个函数叫做运算符重载函数(常为类的成员函数). 方法与解释 ◆ 1.定义运 ...

随机推荐

  1. Oracle导入、导出数据库dmp文件

    版本 1.实例数据完全导出 即导出指定实例下的所有数据 exp username/password@192.168.234.73/orcl file=d:/daochu/test.dmp full=y ...

  2. css_属性

    老师的博客:https://www.cnblogs.com/liwenzhou/p/7999532.htm css的属性 整体属性的:作用于全局 width:表示宽 height:表示长 color: ...

  3. KindEditor富文本编辑器使用

    我的博客本来打算使用layui的富文本编辑器,但是出了一个问题,无法获取编辑器内容,我参考官方文档,获取内容也就那几个方法而已,但是引入进去后始终获取的值为空,百度和bing都试过了,但是始终还是获取 ...

  4. kubernetes1.14.0部署

    2019/4/6/使用kubeadm安装部署kubernetes集群: 前提:1.各节点时间同步:2.各节点主机名称解析:dns OR hosts:3.各节点iptables及firewalld服务被 ...

  5. sigsuspend()阻塞:异步信号SIGIO为什么会被截胡?

    关键词:fcntl.fasync.signal.sigsuspend.pthread_sigmask.trace events. 此文主要是解决问题过程中的记录,内容有较多冗余.但也反映解决问题中用到 ...

  6. Web Storage和cookie

    Cookie的作用是与服务器进行交互,作为HTTP规范的一部分而存在 ,而Web Storage仅仅是为了在本地“存储”数据而生; Web Storage的概念和cookie相似,区别是它是为了更大容 ...

  7. 微信小程序中用户登录和登录态维护

    提供用户登录以及维护用户的登录状态,是一个拥有用户系统的软件应用普遍需要做的事情.像微信这样的一个社交平台,如果做一个小程序应用,我们可能很少会去做一个完全脱离和舍弃连接用户信息的纯工具软件. 让用户 ...

  8. C#自定义应用程序上下文对象+IOC自己实现依赖注入

    以前的好多代码都丢失了,加上最近时间空一些,于是想起整理一下以前的个人半拉子项目,试试让它们重生.自从养成了架构师视觉 搭建框架之后,越来 越看不上以前搭的框架了.先撸个上下文对象加上实现依赖注入.由 ...

  9. Xshell 连接Linux服务器自动中断问题

    Xshell连接上Linux服务器后经常自动中断连接,报错如下图: 解决方法如下,进入/etc/ssh目录打开sshd_config文件,找到下图两个参数并设置下图所示的值: 重启sshd即可解决,如 ...

  10. C#直接使用DllImport调用C/C++动态库(dll文件)

    1.C/C++动态库的编写 下面是我编写的一个比较简单的C++dll文件用来测试,关于如何编写dll文件,我这里便不再赘述,不懂得自行查询, (1).h文件 #ifdef MYDLL_EXPORTS ...