【C++初级技能书】2.运算符

各位同学大家好啊，这一章我们讲运算符。

1.什么是运算符？

运算符并没有一个明确的定义，一般来说对变量进行操作的就是运算符。像我们日常使用的+、-、*、/（加、减、乘、除）等等都是运算符。

2.运算符的例子

#include <iostream> 
using namespace std;
int main() 
{ 
    int a=10; 
    a=a+1;     
    cout<<a<<endl; 
    return 1; 
}

上面的例子最终的输出结果就是11。这个程序最初声明了一个整型变量a，并赋值10（等于号=的操作，我们称为赋值），然后给a加上1，这时得到结果11，但是注意此时在计算机中a的值还是10，需要将结果再使用等号=赋值给a，a最终才会变成11。

3.C++中的基本运算符

• 算术运算符:用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减 (--)共七种。
• 关系运算符:用于比较运算。包括大于(>)、小于(<)、等于(==)、 大于等于(>=)、小于等于(<=)和不等于(!=) 六种。
• 逻辑运算符:用于逻辑运算。包括与(&&)、或(||)、非(!)三种。
• 位操作运算符:参与运算的量，按二进制位进行运算。包括位与(&)、位或 (|)、位非 (~)、位异或(^)、左移 (<<)、 右移(>>)六种。
• 赋值运算符:用于赋值运算，分为简单赋值(=)、复合算术赋值(+=,-=,*=,/=,%=)和复合位运算赋值 (&=,|=,^=,>>=,<<=)三类共十一种。
• 条件运算符:这是一个三目运算符，用于条件求值(?:)。
• 逗号运算符:用于把若干表达式组合成一个表达式(，)。
• 指针运算符:用于取内容(*)和取地址(&)二种运算。
• 求字节数运算符:用于计算数据类型所占的字节数(sizeof)。
• 特殊运算符:有括号()，下标[]，成员(→，.)等几种。

注意：很多语言的基本运算符都是一样的，不用死记硬背。

4.运算符的优先级

在C++中，运算符是有优先级的，同优先级的从左至右依次执行，不同优先级的，高优先级的先执行，就比如我们要计算1+2*3这个式子，那我们都知道要先计算2*3，然后再计算加法，而计算机是通过优先级来判断先执行哪一部分。

运算符	描述	例子	可重载性
第一级别
::	作用域解析符	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_from);	不可重载
dynamic_cast	特殊属性转换	dynamic_cast(type_from);	不可重载
static_cast	特殊属性转换	static_cast(type_from);	不可重载
reinterpret_cast	特殊属性转换	reinterpret_cast(type_from);	不可重载
typeid	对象类型符	cout « typeid(var).name(); cout « 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++ ) …	可重载

上面表格抄了一下百度百科的运算符优先级页面，有需要可以点击下面的链接跳转

https://baike.baidu.com/item/%E8%BF%90%E7%AE%97%E7%AC%A6%E4%BC%98%E5%85%88%E7%BA%A7/4752611?fr=aladdin

当然表格也不需要死记硬背，如果你的程序出现了意料之外的结果，并且包含运算符，可以考虑是不是运算符的优先级没有考虑好。

 

思考一下（答案不唯一）

• 有一个表达式，1+2*3+4*5+6，怎么修改能让计算机按顺序从左到右计算？

  • #include <iostream>
    using namespace std;
    int main()
    {
        //加括号可以改变优先级
        int a = (((((1 + 2) * 3) + 4) * 5) + 6);
        cout<<a<<endl;
    
        getchar();
        return 1;
    }