一:运算符重载的限制

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

+    -   *    /     %      ^     &    |    ~
!    =   <   >    +=    -=   *=   /= %=
^=   &= |=   <<   >>    <<=   >>=  == !=
<=   >= &&   ||   ++    --   ,   ->* ->
()  []   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. duilib

    https://www.cnblogs.com/lin1270/p/4109305.html

  2. 5000量子位支持量子编程,D-Wave推出下一代量子计算平台计划

    5000量子位支持量子编程,D-Wave推出下一代量子计算平台计划 近日,全球量子商用化重要参与者 D-Wave 公司又有大动作:推出其5000量子比特量子计算的发展蓝图.D-Wave 下一代量子计算 ...

  3. ubuntu18.04搭建hive

    hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张数据库表,并提供简单的sql查询功能,可以将sql语句转换为MapReduce任务进行运行. 其优点是学习成本低,可以通过 ...

  4. android开发学习 ------- 关于getSupportFragmentManager()不可用的问题

    在Android开发中,少不了Fragment的运用. 目前在实际运用中,有v-4包下支持的Fragment以及app包下的Fragment,这两个包下的FragmentManager获取方式有点区别 ...

  5. TensorRT&Sample&Python[fc_plugin_caffe_mnist]

    本文是基于TensorRT 5.0.2基础上,关于其内部的fc_plugin_caffe_mnist例子的分析和介绍. 本例子相较于前面例子的不同在于,其还包含cpp代码,且此时依赖项还挺多.该例子展 ...

  6. vc图像合成

    本程序下载地址: 上一篇讲述了tiff格式图片拆分成多张图片, 这篇博客讲述如何把多张任意格式的图片合成为一张图片. 图像合成仍然需要借助Cximage图像库,合成函数为Mixfrom, 函数原型为: ...

  7. .net 信息采集ajax数据

    .net 信息采集ajax数据 关于.net信息采集的资料很多,但是如果采集的网站是ajax异步加载数据的模式,又如何采集呢?今天就把自己做信息采集时,所遇到的一些问题和心得跟大家分享一下. 采集网站 ...

  8. 在QT中使用C/C++, 在linux下生成 .so, 并调用 .so

    时间不早了, 先下班了... 明天再写..

  9. Callable,Future和FutureTask详解

    1.Callable和Runnable 看Callable接口: public interface Callable<V> { /** * Computes a result, or th ...

  10. 在写php项目时 修改外部css或js文件没有效果

    原因是:浏览器的自动缓存机制导致的. 这是因为浏览器会自动缓存静态文件以加快访问速度,所以这就导致浏览器将不会再接收静态文件了 解决办法是 使用ctrl+F5 —— 传说中的完全刷新,会删掉所有本地临 ...