C++ 运算符

最新推荐文章于 2023-10-15 18:03:08 发布
最新推荐文章于 2023-10-15 18:03:08 发布
阅读量217 收藏
点赞数 1
分类专栏： C加加 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78835635/article/details/131430663
版权

C++ 运算符

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

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符
  • 杂项运算符

本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。

算术运算符

下表显示了 C++ 支持的算术运算符。

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

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

实例

请看下面的实例，了解 C++ 中可用的算术运算符。

复制并粘贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

实例

#include <iostream> using namespace std; int main() { int a = 21; int b = 10; int c; c = a + b; cout << "Line 1 - c 的值是 " << c << endl ; c = a - b; cout << "Line 2 - c 的值是 " << c << endl ; c = a * b; cout << "Line 3 - c 的值是 " << c << endl ; c = a / b; cout << "Line 4 - c 的值是 " << c << endl ; c = a % b; cout << "Line 5 - c 的值是 " << c << endl ; int d = 10; // 测试自增、自减 c = d++; cout << "Line 6 - c 的值是 " << c << endl ; d = 10; // 重新赋值 c = d--; cout << "Line 7 - c 的值是 " << c << endl ; return 0; }

当上面的代码被编译和执行时，它会产生以下结果：

Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 10
Line 7 - c 的值是 10

关系运算符

下表显示了 C++ 支持的关系运算符。

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

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

实例

请看下面的实例，了解 C++ 中可用的关系运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

实例

#include <iostream> using namespace std; int main() { int a = 21; int b = 10; int c ; if( a == b ) { cout << "Line 1 - a 等于 b" << endl ; } else { cout << "Line 1 - a 不等于 b" << endl ; } if ( a < b ) { cout << "Line 2 - a 小于 b" << endl ; } else { cout << "Line 2 - a 不小于 b" << endl ; } if ( a > b ) { cout << "Line 3 - a 大于 b" << endl ; } else { cout << "Line 3 - a 不大于 b" << endl ; } /* 改变 a 和 b 的值 */ a = 5; b = 20; if ( a <= b ) { cout << "Line 4 - a 小于或等于 b" << endl ; } if ( b >= a ) { cout << "Line 5 - b 大于或等于 a" << endl ; } return 0; }

当上面的代码被编译和执行时，它会产生以下结果：

Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

逻辑运算符

下表显示了 C++ 支持的关系逻辑运算符。

假设变量 A 的值为 1，变量 B 的值为 0，则：

运算符描述实例
&&称为逻辑与运算符。如果两个操作数都 true，则条件为 true。(A && B) 为 false。
||称为逻辑或运算符。如果两个操作数中有任意一个 true，则条件为 true。(A || B) 为 true。
!称为逻辑非运算符。用来逆转操作数的逻辑状态，如果条件为 true 则逻辑非运算符将使其为 false。!(A && B) 为 true。

实例

请看下面的实例，了解 C++ 中可用的逻辑运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

实例

#include <iostream> using namespace std; int main() { int a = 5; int b = 20; int c ; if ( a && b ) { cout << "Line 1 - 条件为真"<< endl ; } if ( a || b ) { cout << "Line 2 - 条件为真"<< endl ; } /* 改变 a 和 b 的值 */ a = 0; b = 10; if ( a && b ) { cout << "Line 3 - 条件为真"<< endl ; } else { cout << "Line 4 - 条件不为真"<< endl ; } if ( !(a && b) ) { cout << "Line 5 - 条件为真"<< endl ; } return 0; }

当上面的代码被编译和执行时，它会产生以下结果：

Line 1 - 条件为真
Line 2 - 条件为真
Line 4 - 条件不为真
Line 5 - 条件为真

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

pqp & qp | qp ^ q
00000
01011
11110
10011

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

下表显示了 C++ 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符描述实例
&

按位与操作，按二进制位进行"与"运算。运算规则：

0&0=0;   
0&1=0;    
1&0=0;     
1&1=1;
(A & B) 将得到 12，即为 0000 1100
|

按位或运算符，按二进制位进行"或"运算。运算规则：

0|0=0;   
0|1=1;   
1|0=1;    
1|1=1;
(A | B) 将得到 61，即为 0011 1101
^

异或运算符，按二进制位进行"异或"运算。运算规则：

0^0=0;   
0^1=1;   
1^0=1;  
1^1=0;
(A ^ B) 将得到 49，即为 0011 0001
~

取反运算符，按二进制位进行"取反"运算。运算规则：

~1=-2;   
~0=-1;
(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。A << 2 将得到 240，即为 1111 0000
>>二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。A >> 2 将得到 15，即为 0000 1111

实例

请看下面的实例，了解 C++ 中可用的位运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

实例

#include <iostream> using namespace std; int main() { unsigned int a = 60; // 60 = 0011 1100 unsigned int b = 13; // 13 = 0000 1101 int c = 0; c = a & b; // 12 = 0000 1100 cout << "Line 1 - c 的值是 " << c << endl ; c = a | b; // 61 = 0011 1101 cout << "Line 2 - c 的值是 " << c << endl ; c = a ^ b; // 49 = 0011 0001 cout << "Line 3 - c 的值是 " << c << endl ; c = ~a; // -61 = 1100 0011 cout << "Line 4 - c 的值是 " << c << endl ; c = a << 2; // 240 = 1111 0000 cout << "Line 5 - c 的值是 " << c << endl ; c = a >> 2; // 15 = 0000 1111 cout << "Line 6 - c 的值是 " << c << endl ; return 0; }

当上面的代码被编译和执行时，它会产生以下结果：

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

赋值运算符

下表列出了 C++ 支持的赋值运算符：

运算符描述实例
=简单的赋值运算符，把右边操作数的值赋给左边操作数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 |= 2 等同于 C = C | 2

实例

请看下面的实例，了解 C++ 中可用的赋值运算符。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

实例

#include <iostream> using namespace std; int main() { int a = 21; int c ; c = a; cout << "Line 1 - = 运算符实例，c 的值 = : " <<c<< endl ; c += a; cout << "Line 2 - += 运算符实例，c 的值 = : " <<c<< endl ; c -= a; cout << "Line 3 - -= 运算符实例，c 的值 = : " <<c<< endl ; c *= a; cout << "Line 4 - *= 运算符实例，c 的值 = : " <<c<< endl ; c /= a; cout << "Line 5 - /= 运算符实例，c 的值 = : " <<c<< endl ; c = 200; c %= a; cout << "Line 6 - %= 运算符实例，c 的值 = : " <<c<< endl ; c <<= 2; cout << "Line 7 - <<= 运算符实例，c 的值 = : " <<c<< endl ; c >>= 2; cout << "Line 8 - >>= 运算符实例，c 的值 = : " <<c<< endl ; c &= 2; cout << "Line 9 - &= 运算符实例，c 的值 = : " <<c<< endl ; c ^= 2; cout << "Line 10 - ^= 运算符实例，c 的值 = : " <<c<< endl ; c |= 2; cout << "Line 11 - |= 运算符实例，c 的值 = : " <<c<< endl ; return 0; }

当上面的代码被编译和执行时，它会产生以下结果：

Line 1 - =  运算符实例，c 的值 = 21
Line 2 - += 运算符实例，c 的值 = 42
Line 3 - -= 运算符实例，c 的值 = 21
Line 4 - *= 运算符实例，c 的值 = 441
Line 5 - /= 运算符实例，c 的值 = 21
Line 6 - %= 运算符实例，c 的值 = 11
Line 7 - <<= 运算符实例，c 的值 = 44
Line 8 - >>= 运算符实例，c 的值 = 11
Line 9 - &= 运算符实例，c 的值 = 2
Line 10 - ^= 运算符实例，c 的值 = 0
Line 11 - |= 运算符实例，c 的值 = 2

杂项运算符

下表列出了 C++ 支持的其他一些重要的运算符。

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

C++ 中的运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

类别 运算符 结合性 
后缀 () [] -> . ++ - -  从左到右 
一元 + - ! ~ ++ - - (type)* & sizeof 从右到左 
乘除 * / % 从左到右 
加减 + - 从左到右 
移位 << >> 从左到右 
关系 < <= > >= 从左到右 
相等 == != 从左到右 
位与 AND & 从左到右 
位异或 XOR ^ 从左到右 
位或 OR | 从左到右 
逻辑与 AND && 从左到右 
逻辑或 OR || 从左到右 
条件 ?: 从右到左 
赋值 = += -= *= /= %=>>= <<= &= ^= |= 从右到左 
逗号 , 从左到右 

实例

请看下面的实例，了解 C++ 中运算符的优先级。

复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。

对比有括号和没有括号时的区别，这将产生不同的结果。因为 ()、 /、 * 和 + 有不同的优先级，高优先级的操作符将优先计算。

实例

#include <iostream> using namespace std; int main() { int a = 20; int b = 10; int c = 15; int d = 5; int e; e = (a + b) * c / d; // ( 30 * 15 ) / 5 cout << "(a + b) * c / d 的值是 " << e << endl ; e = ((a + b) * c) / d; // (30 * 15 ) / 5 cout << "((a + b) * c) / d 的值是 " << e << endl ; e = (a + b) * (c / d); // (30) * (15/5) cout << "(a + b) * (c / d) 的值是 " << e << endl ; e = a + (b * c) / d; // 20 + (150/5) cout << "a + (b * c) / d 的值是 " << e << endl ; return 0; }

当上面的代码被编译和执行时，它会产生以下结果：

(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50

笔记

& ：只有2个都为1，那么结果是1，否则为0；例如：1&1=1，1&0=0，0&0=0，0&1=0；

11 & 3 = 3

   00001011
&  00000011
=  00000011 = 3

| ：只要有一个是1，那么结果为1，否则为0；例如：1&1=1，1&0=1，0&0=0，0&1=1；

11 | 3 = 11

   00001011
|  00000011
=  00001011 = 11

>> ：向右位移，就是把尾数去掉位数，例如：153 >> 2，153的二进制是：10011001，屁股后面去掉 2 位 100110，100110 转化成十进制就是 38，153 = 10011001，38 =100110，"01" 去掉了。

<< ：向左位移，就是把开头两位数去掉，尾数加位数00，例如：

107 = 0110 1011 <<2
<<
172 = 1010 1100

在计算机中由于是32位的

107 = 0000 0000   0000 0000   0000 0000   0110 1011 <<2
<<
428 = 0000 0000   0000 0000   0000 0001   1010 1100

^ ：两个相同的数会变成0，反之是1，例如：1&1=0，1&0=1，0&0=0，0&1=1；

11^3 = 8

   00001011
^  00000011
=  00001000 = 8

  1. 关于逻辑运算符 && ，|| 的巧用方式

    逻辑与 &&

    && 会先判断左边的值是否为真。

    如果为假，那么整个表达式毫无疑问也为假。

    如果为真，那就还需要判断右值，才能知道整个式子的值。

    这个时候判断右值的过程就起了一个if的作用，可以利用这个过程判断右边表达式是否为真。

    下面代码：

    /*不用任何循环语句，不用if，来实现1+2+3+...+10的值*/
#include <iostream>
using namespace std;

int add(int c)
{
    int a=0;
    c&&(a=add(c-1));//递归循环，直到传入c的值为0则结束循环
    cout<<c+a<<endl;
    return c+a;
}
int main()
{ 
    add(10);
    return 0;
}

    逻辑或 ||

    其实与上面的逻辑与 && 大同小异。

    都是先判断左边是否为真，再来考虑右边。

    因为逻辑与 || 只需要左边为真，那么整个表达式就有值，就不会再去算右边的值了。

    所以我们加个 ! 让 c 值为假时，!c 才为真，这样的话逻辑与 || 还需要判断右边的表达式才能计算出整个表达式的值。

    (!c)||(a=add(c-1));

    这样就达到了和用逻辑与&&时一样的目的。

    代码：

    /*不用任何循环语句，不用if，来实现1+2+3+...+10的值*/
#include <iostream>
using namespace std;

int add(int c)
{
    int a=0;
    (!c)||(a=add(c-1));//递归循环，直到传入c的值为0，(!c)就为真，结束循环
    cout<<c+a<<endl;
    return c+a;
}
int main()
{ 
    add(10);
    return 0;
}
    ccf

       ccf

      

  2. 除法/和求模%若两个操作数是正数，则除法的结果是正数，求模的结果也是正数若两个操作数是负数，则除法的结果是正数，求模的结果是负数若只有一个操作数是负数，则除法和求模的结果取决于机器，除法可以确定结果是负数逻辑与和逻辑或操作符总是先计算其左操作数，然后再计算其右操作数，只有在仅靠左操作数的值无法确定该逻辑表达式的结果时，才会求解其右操作数区分 if(i<j<k) 和 if(i<j && j<k)第一个i<j或者为0或者为1，只要k大于1，表达式就为true第二个必须i<j且j<k表达式才为true区分 if(val) 和 if(val == true)第一个只要val非零则表达式为true,val为0则表达式为false第二个只有val为1表达式为true,val非1则表达式为false

    int val = 2;
if(val==true){              //不会进入if
  cout<<"val==true"<<endl;
}

    多个赋值操作符中，各对象必须具有相同的数据类型，或者具有可转换为同一类型的数据类型。

    int ival; int *pval;
ival = pval = 0;  //error 尽管ival和pval都可以赋值为0
string s1,s2;
s1 = s2 = "OK"    //ok

    如果指针指向不是用new分配的内存地址，则在该指针上使用delete是不合法的。

    通常编译器不能断定一个指针是否指向动态对象，因此尽管这样做是错误的，但在大部分编译器上仍能运行通过，但是会产生运行时错误。整形提升

    对于所有比int小的整形(char, signed char, unsigned char, short, unsigned short)，如过该类型所有可能值都包含在int中，他们会被提升为int型，否则，他们将被提升为unsigned int。

    对于包含signed和unsigned int型的表达式，表达式中的signed型整数会被转换为unsigned型。

    int i = -5;
unsigned int ii = 1;
cout<<(i>ii)<<endl;   //输出1，非常有趣的结果 原因是int型的i转换为unsigned int型
short i = -5;
unsigned short ii = 1;
cout<<(i>ii)<<endl;  //输出0 比较时short和unsigned short都提升为int型
    lhshengshi

       lhshengsi

  3. C++ 中的 --> 操作符?

    --> 并不是一个操作符，实际上它是两个独立的操作符：-- 和 >。

    以下代码中我们设置了一个 x 自减的条件运算符代码，在 x 的进行自减运算前，会先使用比较符号 > 与右边表达式 0 进行比较，然后返回结果再进行自减运算：

    while (x --> 0)

// 相等于以下代码
while( (x--) > 0 )
// 把两个运算符分开更好理解了

while (x-- > 0)

    实例 1：输出 0 到 9 的 整数

    #include <stdio.h>
int main()
{
    int x = 10;
    while (x --> 0) 
    {
        printf("%d ", x);
    }
}

    输出结果：

    9 8 7 6 5 4 3 2 1 0

    实例 2: 输出 大于 0 小于 10 的偶数

    #include <stdio.h>
int main()
{

    int x = 10;

    while( 0 <---- x )
    {
       printf("%d ", x);
    }
}

    输出结果：

    8 6 4 2

    实例 3

    #include <stdio.h>
int main()
{
    int x = 100;

    while( 0 <-------------------- x )
    {
       printf("%d ", x);
    }
}

    输出结果：

    90 80 70 60 50 40 30 20 10

  4. 任何数异或 ^0 得到的值不变:

    a^0 = a

    任何数异或同一个数两次得到的值不变:

    a^b^b = a
    cool

       cool

      

  5. int 的除法陷阱

    在工作中遇到了一个 int 的陷阱：当除数和被除数都是整型数据时，得到的结果也是整型数据，它将小数部分舍去，相当于求模运算。

    实例 1：余数小于 0. 5 时:

    int N=819;
std::cout<<N/12<<std::endl;
std::cout<<N/12.0<<std::endl;

    输出：

    68
68.25

    实例 2：余数大于 0.5 时:

    int N=819;
std::cout<<N/10<<std::endl;
std::cout<<N/10.0<<std::endl;

    输出：

    81
81.9

  6. 补充上面老哥写的 “int的处发现陷阱”

    如果输出结果前面有对结果的类型进行定义，则按照定义的规矩走。

    例如：

    double d_1 = 7.0;
double d_2 = 11.0;
double result_1 = d_1 / 2;;
double result_2 = d_2 / 2.0;
cout << "7.0 / 2 = " << result_1 << endl;
cout << "11.0 / 2.0 = " << result_2 << endl;

    输出：

    7.0 / 2 = 3.5
11.0 / 2.0 = 5.5

    但是，如果想要得到 double 类型的数据，最好还是保证除数是带小数点的，这样写更加规范。

    Buktop

       

  7. 对取模运算符 % 的优化。

    在特殊情况下，可以用位运算符 & 来取代 %，从而提高程序运行效率。

    这种特殊情况就是取得模是 2 的 n 次幂，如：2、4、8、16...等。

    先看个例子：

    int a,b,c;
a=53;
b=a%8;                //给a取模8
c=a&7;                //让a和7进行位运算"与"
std::cout<<"b="<<b<<std::endl;
std::cout<<"c="<<c<<std::endl;

    输出：

    b=5
c=5

    你会发现 %8 和 &7 是等价的。

    事实上无论把 a 换成任何范围内正整数，结果 b 都是和 c 一样的。

    同理 %16 等价于 &15，%32 等价于 &31 .......

    看起来适用范围并不广，所以用到最多的实际上是 &1 和 &3。

    再来说一下实际优化效果。

    调用取模 % 的话，通常需要 2 到 3 个运算周期，当数字太大时周期相应增加。

    而使用与运算 & 的话，只需要 1 个运算周期，周期也随数字增加而增加。

    对比得，运算周期减少了。

    虽然效果不明显，但代码的优化就在于这一点点

  8. 取模运算 % 和 取地址运算 & 的优化。

    有以下三个是可以等价的：

    %2 == &1
%4 == &3
%8 == &7

    测试代码：

    #include <iostream>
using namespace std;

int main()
{
    int a = 2325,i, da = 0, db = 0;
    
    cout<<"i  %  &"<<endl;
    for(i = 1; i<10;i++)
    {
        da = a%(i+1);
        db = a&i;
        if(!(da^db)) 
            cout<<i<<"  "<<da<<"  "<<db<<endl;
    }
    return 0;
}
    DomE

      

  9. 运算符优先级助记歌（自己编的，优先级从高到低）：

    先算右一后左一，①

    乘除加减移位比。②

    与异或或位逻辑，③

    三目赋值逗号稀。④

    ①先算右面的一元运算符，后算左面的。

    ②乘除代表*/%，加减就是+和-，移位就是<<和>>，比就是比较运算符，注意比较运算符先算<、>、<=和>=这4个含不等号的，后算==和!=这两个。

    ③先算按位逻辑运算符，再算普通的逻辑运算符；按位逻辑运算符的顺序是&^|，逻辑运算符先算&&再算||，只是少了逻辑异或。

    ④先算三目运算符，再算赋值运算符，逗号运算符的优先级最低，所以说它“稀”

杨得江-君临天下wyj
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
[开发|C++] C++的基本运算符说明笔记
梦醒贰零壹柒
05-21 3265
逻辑或运算符，用于执行逻辑或操作，当且仅当两个操作数中至少一个为真时结果为真。：逻辑与运算符，用于执行逻辑与操作，当且仅当两个操作数都为真时结果为真。：加法赋值运算符，相当于将左操作数与右操作数相加后再赋给左操作数。：减法赋值运算符，相当于将左操作数与右操作数相减后再赋给左操作数。：大于等于运算符，用于比较左操作数是否大于等于右操作数。：小于等于运算符，用于比较左操作数是否小于等于右操作数。：逻辑非运算符，用于执行逻辑非操作，将操作数的值取反。：赋值运算符，用于将右操作数的值赋给左操作数。
C++中 i＜＜=1是什么意思
weixin_46195203的博客
11-24 1万+
左移赋值运算。 变量i 左移1位，结果仍然保存到变量i 举个栗子： i=101001 执行： i<<=1 之后i=1010010 此处多了一个0 实际使用中多用来筛选，如形同取0,不同取1 for (a=1,a<10,a++){ census_value <<= 1; if (gray==gray_center) { census_value += 1; } 这样最后查看census_calue 中1的个数即可知道相同的个数 ...
【C++】＞＞ 与 ＜＜ 符号作用
littlegengjie的博客
10-15 3035
2 >> 1：相当于2/2。99 >> 1: 相当于 99/2 向下取整为49。99 >> 2：相当于 99/pow(2,2)向下取整为24。999 >> i：相当于999 / pow(2,i)。整数 >> i：相当于将这个整数化为二进制整数，并去掉这个数的末尾的 i 位数字。
c++＞＞和＜＜的用法
wyz1791678752的博客
02-25 1万+
c++>>和
＜＜ 和 ＞＞ 在 C++ 里面是什么意思
热门推荐
lymww的博客
08-05 3万+
前言： 本文讲的是c++中<<(左移)和>>(右移)的作用，以及实现的时候发生了什么，如有错误，敬请斧正，希望能对大家有所帮助 原码反码补码 在其之前我们要先了解计算机里面的三种机械数 计算机都是通过数字的补码进行运算 原码 原码是人类的正常理解方式的二进制，即首位表示的是正负号，其余位表示的是数值。 反码 负数的反码是除了符号位不变其余的0变1，1变0，正数的反码还是它本身 补码 负数的补码是除了符号位不变其余的0变1，1变0，最后在再1，正数的反码还是它本身 <&l
C++运算符重载规则详解
09-03
主要介绍了C++运算符重载规则详解,是C++入门学习中的基础知识,需要的朋友可以参考下
C++运算符优先级汇总表
12-28
1. 赋值运算符：包括常见的赋值符号“=”，以及复合赋值运算符如“+=”、“-=”、“*=”、“/=”、“%=”、“&=”、“|=”、“^=”、“”、“>>=”等。这些运算符用于将一个值赋给变量，或者将一个表达式的值赋给...
C++运算符重载
05-18
C++运算符重载:赋予运算符另一种作用，实现自定义类型的运算C++运算符重载内容： 1.友元重载 2.类重载 3.输入输出流重载
C++运算符优先级 .pdf
05-08
C++运算符优先级整理
C++运算符重载课件
09-17
中国农业大学C++课程课件，信息与电气工程学院学生专用。
C++运算符优先级
01-09
c++的运算符优先级 很有用的东西 对编程不是很熟悉的人可以看看 对于熟悉变成的人来说 也可以作为参考
C++运算符.doc
02-19
C++运算符优先级，是描述在计算机运算计算表达式时执行运算的先后顺序。 先执行具有较高优先级的运算，然后执行较低优先级的运算。 例如，我们常说的先执行相乘和除，再执行加减运算。 C++运算符优先级表，从上...
c++运算符重载基础知识详解
09-04
运算符重载是一种形式的C++多态。运算符重载将重载的概念扩展到运算符上，允许赋予C++运算符多种含义
C++运算符重载的思维导图
最新发布
03-26
运算符重载 、运算符重载规则 1.重载运算符的限制 2.运算符重载的语法形 式 、用成员或友元函数重载运算符 1.一元运算符2.二元运算符 3.用成员函数重载运算符 4.用友元函数重载 条件 ②例子 ③注意 5.讨论 6.总结 三...
c++ 运算符优先级 运算符优先级 备赛
10-05
C++ 运算符优先级总表 使用C++语言参赛的OIer 赛前复习 记得保存~~
[翻译]C++20新运算符之三元比较符<=>
S1xe的博客
12-14 6969
C++20新特性 C++20新运算符 <=> Three-way_comparison 翻译 三元比较符
C++基础知识 - 重载关系运算符＞、＜、==
骆驼胡杨的博客
02-21 875
重载关系运算符>、<、== C++ 语言支持各种关系运算符（ < 、 > 、 <= 、 >= 、 == 等等），它们可用于比较 C++ 内置的数据类型，返回值为bool类型。 可以重载任何一个关系运算符，重载后的关系运算符可用于比较类的对象。 下面的实例演示了如何重载 < 运算符，类似地，也可以尝试重载其他的关系运算符。 Boy.h #pragma once #include <string> using namespace std;
C++20新特性—三路比较符＜=＞
guxch的专栏
01-29 3700
集合（set,map等）算法通常会涉及元素比大小，因此两个元素（类型）的比较操作就显得额外重要。两个类型之间的共有六种比较符（<,<=,>,>=,==,!=），如果需要完整的表达，就要写六个函数，如果需要与可转换类型比较，这项工作显得比较繁琐，因此这也是C++引入<=>的基本初衷。【如果认为用一个比较符，例如”<”就可以推导出另外几个，其实这只适用于一些场景，这也是C++引入新的比较操作符的另一个原因。】 <=>称为3-way comparison o
C++操作符重载（++、=、<<、==、!=）
zxjzlj的专栏
07-09 573
C++有个很重要的
c++ 运算符优先级
09-06
- *1* [C++运算符的优先级](https://blog.csdn.net/ITJAVAtao/article/details/120597987)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杨得江-君临天下wyj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值