C++的运算符与表达式

最新推荐文章于 2024-07-05 18:03:00 发布

turbolove

最新推荐文章于 2024-07-05 18:03:00 发布

阅读量858

点赞数 1

分类专栏： # 重构C++知识体系文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/turbolove/article/details/130845679

版权

重构C++知识体系专栏收录该内容

7 篇文章 2 订阅

订阅专栏

C++的运算符与表达式

运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++内置了丰富的运算符，并且提供了以下类型的运算符：
- 算数运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 杂项运算符

表达式

在程序中，运算符是用来操作数据的，因此这些数据也被称为操作数，使用运算符将操作数连接而成的式子称为表达式

表达式具有如下特点：

常量和变量都是表达式例如常量3.14 变量i
运算符的类型对应表达式的类型，例如算数运算符对应算数表达式
每一个表达式都有自己的值，即表达式都有运算结果

算数运算符

假设变量A的值为10，变量B的值为20则：

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
–	自减运算符，整数值减少 1	A-- 将得到 9

关系运算符

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

逻辑运算符

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
\|\|	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A \|\| B) 为真。
！	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	!(A && B) 为真。

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C = A 相当于 C = C A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
\|=	按位或且赋值运算符	C \|= 等同于 C = C \|2

位运算符

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000 1100
\|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A \| B) 将得到 12，即为 0000 1100
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(A ^ B) 将得到 49，即为 0011 0001
~	二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111

优先级：

位与疏散运算符都是双目运算符，其结合性都是从左到右的，优先级高于逻辑运算符，低于比较云悬浮，且从高到低依次为& ^ |

其他运算符

运算符	描述
sizeof	sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。
Condition ? X : Y	三目运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。
,	逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。
.（点）和 ->（箭头）	成员运算符用于引用类、结构和共用体的成员。
Cast	强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。
&	指针运算符 &返回变量的地址。例如 &a; 将给出变量的实际地址。
*	指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。

运算符的优先级

一般来说，一元运算符优先级高于对应的二元运算符
弄不清楚优先级就加括号

运算符代码演示：

# include <assert.h>
# include <iostream>
using namespace std;

int main()
{
    int A = 10;
    int B = 20;

    // 算术运算符示例
    std::cout << A + B << std::endl;    // 30
    cout << A - B << endl;     // -10
    cout << A*B << endl;       // 200
    cout << B / A << endl;     // 2
    cout << 15 / A << endl;    // 1
    cout << 15.0 / A << endl; // 1.5
    cout << B%A << endl;      // 0
    cout << ++A << endl;      // 11
    cout << A << endl;           // 11
    cout << --A << endl;        // 10
    cout << A << endl;           // 10

    // 关系运算符示例
    cout << (A == B) << endl;  // 0
    cout << (A != B) << endl;   // 1
    cout << (A > B) << endl;    // 0
    cout << (A < B) << endl;    // 1
    cout << (A >= B) << endl;  // 0
    cout << (A <= B) << endl;  // 1

    // 逻辑运算符示例
    bool bA = false, bB = true;
    // to be or not to be
    cout << ( bA == true || bA != true ) << endl;   // 1
    cout << (bB == true || bB != true) << endl;   // 1
    // 德*摩根率
    assert( !(bA || bB) == (!bA && !bB) ); //  1
    assert( !(bA && bB) == (!bA || !bB)  ); //  1
    bA = false, bB = false;
    assert( !(bA || bB) == (!bA && !bB) ); //  1
    assert( !(bA && bB) == (!bA || !bB) ); //  1
    bA = true, bB = true;
    assert( !(bA || bB) == (!bA && !bB) ); //  1
    assert( !(bA && bB) == (!bA || !bB) ); //  1
    bA = true, bB = false;
    assert( !(bA || bB) == (!bA && !bB) ); //  1
    assert( !(bA && bB) == (!bA || !bB) ); //  1

    // 位运算
    cout << (A&B) << endl;      //  01010 & 10100  = 00000  ==> 0

    cout << (A | B) << endl;       //  01010 | 10100  = 11110  ==> 30

    cout << (A^B) << endl;     //  01010 ^ 10100  = 11110 ==> 30

    cout << (~A) << endl;       //  ~0000000000001010 = 11111111111110101   ==> 0000000000001011 ==》 -11

    cout << (A << 2) << endl;  // 00001010 << 2 ==> 00101000‬ ==> 40

    cout << (A >> 2) << endl;// 00001010 >> 2 ==> 00000010 ==> 2


    // 赋值运算符
    int C = A + B;
    cout << C << endl;
    C += A;
    cout << C << endl;
    C -= A;
    cout << C << endl;
    C *= A;
    cout << C << endl;
    C /= A;
    cout << C << endl;
    C %= A;
    cout << C << endl;
    C <<= A;
    cout << C << endl;
    C >>= A;
    cout << C << endl;
    C &= A;
    cout << C << endl;
    C ^= A;
    cout << C << endl;
    C |= A;
    cout << C << endl;

    // 杂项运算符示例
    cout << sizeof(A) << endl;   // 4

    int M = A > B ? 1 : 0;
    cout << M << endl;              // 0
    int D = A < B ? 1 : 0;
    cout << D << endl;              // 1
    int E = (A, B, M);
    cout << E << endl;               // 0
    float F = float(E);
    cout << F << endl;               // 0
    cout << &F << endl;            // 0xFFXXX
    float * P = &F;
    cout << P << endl;              // 0xFFXXX
    cout << *P << endl;             // 0

    typedef struct {
    	short Sunday = 0;
    	short Monday = 1;
    	short Tuesday = 2;
    	short Wednesday = 3;
    	short Thursday = 4;
    	short Friday = 5;
    	short Saturday = 6;
    } Week;
    Week w;
    cout << w.Friday << endl;  // 5
    cout << sizeof(w) << endl; // ?
    return 0;
}

测试的时候按项测试。

语言的注释

程序注释是解释性语句，你可以在C++代码中包含注释，这将提高源代码可读性。所有的编程语言都允许某种形式的注释
C++支持单行注释和多行注释，注释中所有的字符会被C++编译器忽略

#include <iostream>
using namespace std;
/***
 * 多行注释
 * @return
 */
int main()
{
    cout << "单行注释" << std::endl;
    return 0;
}

注释的原则和建议：

好的命名和代码本身就是最好的注释；如果代码本身就清除不需要增加额外的注释
在重要的代码段或者复杂的代码段先写注释再写代码，这样思路清晰，同时可以保证代码和注释一致性
注释不是越多越好，它对代码提示，如果要写就要清楚，并且保证和代码一致性，如果更新了新代码，请更新相应的注释

补码的补充

有没有一个办法使用加法来做减法？

机器数和真值

机器数：

一个数在计算机中的二进制表示形式，叫做这个数的机器数。

机器数是带符号的，在计算机中用一个数的最高位存放符号位，正数为0，负数为1

比如 +3 就是 00000000000000000000000000000011

-3 按照道理就是10000000000000000000000000000011

实际上-3是 11111111111111111111111111111101

真值：

真正的数学意义上的数值。

因为第一位是符号位，所以机器数形式值就不等于真正的数值

00000000000000000000000000000011 --> +3

11111111111111111111111111111101 --> -3

无符号数的编码

用一个函数 $B2U_w$ 的缩写长度为w来表示：
$B2U_w(\vec{x}) = \sum_{i = 0}^{w-1}{x_i2^i}$
0001 = 1

0101 = 5

有符号数的编码

用一个函数 $B2T_w$ 的缩写长度为w来表示：
$B2T_w(\vec{x}) = {-x_{w-1}2^{w-1}} + \sum_{i = 0}^{w-2}{x_i2^i}$
0001 = 1

0101 = 5

1011 = -5

1111 = -1

另外一种计算补码的方法：

对正数：直接按位计算权重之和

对负数：保留符号位，对后面每位取反+1

字节序

一个字（32位机器采用32bits字长4bytes）在内存中如何以byte来存放

两个传统：

大端法：大多数IBM机器，Internet传输
小端法：Intel兼容机

using namespace std;
// 二进制转无符号整型
unsigned int B2U(unsigned int num)
{
    return (unsigned int)(num);
}
// 二进制转有符号整型
int B2T(int num)
{
    return (int)(num);
}
int main()
{
    //  补码机器数调整展示
    int i1 = 0;
    int i2 = -1;
    int i3 = -2147483648;
    int i4 = 2147483647;

    unsigned int  u1 = 0;
    unsigned int  u2 = 4294967295;
    unsigned int  u3 = 2147483648;
    unsigned int  u4 = 2147483647;

    // 补码的真值验证
    cout << B2T(0x00000000) << endl;
    cout << B2T(0xFFFFFFFF) << endl;
    cout << B2T(0x80000000) << endl;
    cout << B2T(0x7FFFFFFF) << endl;
    cout << endl;
    cout << B2U(0x00000000) << endl;
    cout << B2U(0xFFFFFFFF) << endl;
    cout << B2U(0x80000000) << endl;
    cout << B2U(0x7FFFFFFF) << endl;
    return 0;
}

我们在设计软件系统时总是希望软件系统尽可能的简单通用，于是人们希望在只有加法运算器的情况下设计一种方法能计算减法。

位运算补充

左移比较简单：
右移运算会有两种情况：
- 逻辑右移：移走的位填充0；
- 算数右移：移走的位填充与符号位有关，负数填充1；

对于有符号的数，尽可能不适用右移运算 因为到底是逻辑右移还是算数右移取决于编译器。

turbolove

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
C++的运算符与表达式

位与疏散运算符都是双目运算符，其结合性都是从左到右的，优先级高于逻辑运算符，低于比较云悬浮，且从高到低依次为& ^ |我们在设计软件系统时总是希望软件系统尽可能的简单通用，于是人们希望在只有加法运算器的情况下设计一种方法能计算减法。机器数是带符号的，在计算机中用一个数的最高位存放符号位，正数为0，负数为1。一个数在计算机中的二进制表示形式，叫做这个数的机器数。因为第一位是符号位，所以机器数形式值就不等于真正的数值。对负数：保留符号位，对后面每位取反+1。真正的数学意义上的数值。测试的时候按项测试。
复制链接

扫一扫