Linux C++ 操作符/运算符

曾经终败给现在 2022-03-10 01:24 293阅读 0赞

前面我们了解过了变量和常量，今天我们就来撸一撸c++中常见的操作符和运算符。

**赋值运算符**  
复制运算符的作用就是将一个值赋值给一个变量。这里我们就得提一下一个简单的概念。运算符左边的部分称为左值(lvalue/left value)，运算符右边的部分称为：右值(rvalue/right value)。  
其中lvalue必须是一个变量，rvalue可以是一个常量，变量或者是一个运算结果等等。

a = b;
    a = 10;

只要记住一点，复制运算符总是右边给左边赋值。

这里有个写法大家可能经常用到但并没有太过注意，那就是在c++中赋值运算符可以当做另外一个赋值运算符的右值

a = 3 * (b = 3);
    a = b = c = 3;

其中a = 3 \* (b = 3);等价于：

b = 3;
    a = 3 * b;

**数学运算符**

顾名思义就是我们常见的加减乘除运算。

1. +  加法运算    a + b
    2. -  减法运算  a - b
    3. *  乘法运算  a * b
    4. /  除法运算  a / b
    5. % 取模运算，也就是获取余数  ，比如 a = 10 % 3 ; 结果 是 a = 1

**组合运算符**  
组合运算符的使用可以让我们只使用一个基本运算符就可以完成变量值得修改。最常见的就是数学运算符和赋值运算符的组合。

举个例子：

a += 10;

这句代码等价于：

a = a + 10

当然了，类似下面的大家就都知道怎么使用了。

a -= 10;
    a /= 10;
    a * =10;
    a %= 10;

**递增和递减**  
在c++中我们会经常见到递增(++)和递减(–)运算符的身影。没有什么好说的，递增和递减的作用就是将一个变量的值加1或者减去1.

递增：

a++;
    等价于：
    a = a + 1;
    a += 1

递减：

a--;
    等价于：
    a = a - 1;
    a -= 1

不过虽然这两个运算符比较简单，但是还是有些东西需要我们注意的。

递增和递减运算符可以用作前缀，也可以用作后缀，写法如下：

前缀：
    ++a;
    
    后缀:
    a++;

我们需要注意的就是前缀和后缀两种写法的区别。  
当递增或递减运算符用作前缀的时候，变量的值先自增或者自减，然后在计算表达式的值。  
当递增或递减运算符用作后缀的时候，先计算表达式的值，然后变量在自增或者自减。

int a = 10;
        cout << "递增或递减运算符用作前缀时:" << a++ << endl;
        cout << a << endl;
    
        int b = 5;
        cout << "递增或递减运算符用作后缀时:" << ++b << endl;
        cout << b << endl;

输出：

递增或递减运算符用作前缀时:10
    11
    递增或递减运算符用作后缀时:6
    6

**关系运算符**  
关系运算符用来比较两个表达式的。常见的关系运算符可参考下面：

相等 ==
    不等 !=
    大于 >
    小于 <
    大于等于 >=
    小于等于  <=

关系运算符的返回结果是一个bool值，也就是true或者false。当然了编译器的不同，有可能还会返回0或者1,其中0代表false，1代表true。  
看个例子：

int a = 10;
        int b = 5;
        cout << (a == b) << endl;
        cout << (a > b) << endl;
        cout << (a >= b) << endl;
        cout << (a < b) << endl;
        cout << (a <= b) << endl;

结果：

0
    1
    1
    0
    0

**逻辑运算符**

常见的逻辑运算符有下面几种：

1.  取非 (!)  
    这个运算符只有一个操作变量，而且它的位置只能出现在操作变量的左边，唯一的这个运算符只有一个操作变量，而且它的位置只能出现在操作变量的左边，唯一的作用就是取该操作变量的反面值。也就是说如果这个变量或者常量是true，那么反面的话就是false。

示例：

int a = 10;
        int b = true;
        cout << !a << endl;   => 0
        cout << !b << endl;   => 0

1.  && 运算符  
    它对应的是逻辑运算符中的与运算(AND)，它的运算结果取决于两个操作数或者表达式同时为true，表达式的结果才为true，否则为false
2.  || 运算符  
    它对应的是逻辑运算符中的或运算(OR)，它的运算结果取决于两个操作数或者表达式只要有一个结果为true，那么表达式就为true，否则为false。

> 注意：只要第一个表达式为true，就不会进行后面表达式的真假判断，一次类推。

int a  = 10;
        int b = 5;
        
        cout << (a > b && a < 12 ) <<endl;    => 1
        cout << (a > b || a == 5) << endl;     => 1

**条件运算符**

条件运算符是用来计算一个表达式的值，并且根据该表达式的值为true或者false来返回不同的值，在c++中我们也经常称之为三目运算符。

格式：

condition ? result1 : result2;

这个大家只要记住，只要表达式condition的值为true，那么就使用result1，否则使用result2.其中(:)是用来分割两个返回值的。

示例：

cout << (10 > 5 ? "正确" : "错误") << endl;

输出：

正确

**逗号运算符**  
逗号运算符用来将多个表达式分割开来，并且只取最右边的值作为表达式的值返回，这个个人在实际中比较少用。

cout << (15, 20 )<< endl;

输出：

**位运算符**

位运算符使用比特位改变变量的值，也就是改变变量值的二进制表示。

&  AND 逻辑与
    ! OR 逻辑或
    ^ XOR 逻辑异或
    ~ NOT 对1取补，位反转
    << SHL 左移
    >> SHR 右移

int a = 1;
        bitset<sizeof (int)*8 > b(a);
        cout << b << endl;
        cout <<  bitset<sizeof (int)*8 >(a & 1) << endl;
        cout <<  bitset<sizeof (int)*8 >(a | 1) << endl;
         cout <<  bitset<sizeof (int)*8 >(a ^ 1) << endl;
        cout <<  bitset<sizeof (int)*8 >(~a) << endl;
        cout <<  bitset<sizeof (int)*8 >(a << 1) << endl;
        cout <<  bitset<sizeof (int)*8 >(a >> 1) << endl;

输出：

00000000000000000000000000000001
    
    00000000000000000000000000000001   如果两个相应的二进制位都为１，则该位的结果值为1；否则为0。
    00000000000000000000000000000001  如果两个相应的二进制位只要有一个是1，结果就是1；否则为0。
    00000000000000000000000000000000  两个相同的数会变成0，反之是1
    11111111111111111111111111111110   将1变为0，将0变为1
    00000000000000000000000000000010 左移运算符是把操作数的值的每一位向左移动，移动的位数有右边的操作数决定，右侧空出的位数用0填充
    00000000000000000000000000000000  右移运算符是把操作数的值的每一位向右移动，移动的位数有右边的操作数决定，左边丢弃的位数用0填充

**sizeof**  
我们可能经常会用sizeof这个运算符，估计很多朋友会将这个家伙当做c++的一个函数，其实这就是一个运算符，只不过它只接受一个参数，这个参数可以是一个变量也可以是数据类型，返回其在内存中所占的字节数。

int a = 1;
        bitset<sizeof (int)*8 > b(a);
        cout << sizeof(a) << endl;
        cout << sizeof(b) << endl;

输出：

4
    8

运算符的优先级可参考下面的内容：

优先级	运算符	说明	结合性
    1	::	范围解析	自左向右
    2	++   --	后缀自增/后缀自减
    	()	括号
    	[]	数组下标
    	.	成员选择（对象）
    	−>	成员选择（指针）
    3	++   --	前缀自增/前缀自减	自右向左
    	+   −	加/减
    	!   ~	逻辑非/按位取反
    	(type)	强制类型转换
    	*	取指针指向的值
    	&	某某的地址
    	sizeof	某某的大小
    	new, new[]	动态内存分配/动态数组内存分配
    	delete, delete[]	动态内存释放/动态数组内存释放
    4	.*   ->*	成员对象选择/成员指针选择	自左向右
    5	*   /   %	乘法/除法/取余
    6	+   −	加号/减号
    7	<<   >>	位左移/位右移
    8	<   <=	小于/小于等于
    >   >=	大于/大于等于
    9	==   !=	等于/不等于
    10	&	按位与
    11	^	按位异或
    12	|	按位或
    13	&&	与运算
    14	||	或运算
    15	?:	三目运算符	自右向左
    16	=	赋值
    	+=   −=	相加后赋值/相减后赋值
    	*=   /=   %=	相乘后赋值/相除后赋值/取余后赋值
    	<<=   >>=	位左移赋值/位右移赋值
    	&=   ^=   |=	位与运算后赋值/位异或运算后赋值/位或运算后赋值
    17	throw	抛出异常
    18	,	逗号	自左向右

关于优先级的顺序我们大可不必记忆，在实际的使用过程中，推荐大家还是用()来控制我们的优先级，这样可以让我们的代码更加的易读。