用于综合决策的逻辑运算

与C语言完全相同。

现实生活中，任何决策，都是根据多个因素，综合决策的！

有没有钱, 有没有时间, 实力允不允许?

逻辑与  &&

都为真，逻辑与才是真

只要有一个是假， 逻辑与就是假

相当于“而且”

应用场景：

当需要两个条件都满足时，就使用逻辑与

特别注意：

条件1  &&  条件2

当条件1为真时，才去判断条件2

当条件1为假时，就不再判断条件2

多个条件:

条件1 &&  条件2  && 条件3

#include <iostream>
#include <Windows.h>
using namespace std;
int main(void) {
      int money;
      int days;
      cout << "你有多少钱?";
      cin >> money;
      cout << "你看多少天的假期?";
      cin >> days;
      //如果存款大于10万,而且假期大于10天, 就去旅游
      if (money > 100000 && days > 10) {
            cout << "我要去旅游!" << endl;
      } else {
            cout << "还是在家里呆着" << endl;
      }
      system("pause");
      return 0;
}

逻辑或 ||

只要有一个是真， 结果就是真

都为假时，结果才是假

相当于“或者”

多个条件:

条件1  ||   条件2  || 条件3

应用场景：

只需要满足任意一个条件时，就使用逻辑或

特别注意：

条件1  ||  条件2

当条件1为真时，就不再判断条件2

当条件1为假时，才判断条件2

#include <iostream>
#include <string>
#include <Windows.h>
using namespace std;
int main(void) {
      int money;
      string love;
      cout << "你有多少钱?" << endl;
      cin >> money;
      cout << "你爱我吗?" << endl;
      cin >> love;  //回答: 爱  或者  不爱
      if (money > 1000000  ||   love == "爱" ) {
            cout << "我们结婚吧!" << endl;
      } else {
            cout << "你是一个好人!" << endl;
      }
      system("pause");
      return 0;
}

逻辑非 !

是”单目运算符”, 即:只有一个操作数

!条件

相当于“不”

应用场景：

当需要不满足某条件时，就使用逻辑非

特别注意：

逻辑非，只对一个条件进行运算！

是一种“单目运算符”

#include <iostream>
#include <Windows.h>
using namespace std;
int main(void) {
      int money;
      int days;
      cout << "你的月薪多少?";
      cin >> money;
      if (!(money >= 30000)) {
            cout << "我是菜鸟, 薪资不到3万, 我要努力修炼!\n" << endl;
      } else {
            cout << "我要接外包\n" << endl;
      }
      system("pause");
      return 0;
}

操作硬件的位运算

问题:

把地址为0x80040的寄存器的最低4位设置为0110

解决方案:

使用位操作

什么是位?

内存的基本单元是字节, 一个字节有8位.

位与 &

0 & 0   0

0 & 1   0

1 & 0   0

1 & 1   1

对应位, 都是1,  结果才是1

// 00001000

// 00000011

// 00000000

cout <<  " 8 & 3 = " << (8 & 3) << endl;  

位或 |

0  |  0   0

0  |  1   1

1  |  0   1

1  |  1   1

对应位, 都是0, 结果才是0

只要有一位是1, 结果就是1

// 00001000

// 00000011

// 00001011

cout <<  " 8 | 3 = " << (8 | 3) << endl;

位非 ~

~ 1   0

~ 0   1

取反

// 00001000

unsignedchar x = ~8;

cout << (int)x << endl;  //247

异或 ^

0 ^ 0  0

1 ^ 1  0

0 ^ 1  1

1 ^ 0  1

对应位不同, 结果才是1

// 00001000

// 00000011

// 00001011

cout << (8^3) << endl;  //11

<< 左移

右边的位用 0 来填充, 移动超出左边边界的位则直接抛弃。

向左移动 n个位置，就等同于乘以 2的n次方

只适用于: int/short/long/char 等定点数类型(float/double浮点数类型不能使用)

// 00001000

// 01000000

cout << (8<<3) << endl;   //8*2*2*2 = 64

>> 右移

如果左操作数是无符号类型，则左边多出来的位用 0 来填充。

如果左操作数是有符号类型，则左边多出来的位用 符号位(最高位) 来填充。

向左移动 n个位置，就等同于除以 2的n次方

只适用于: int/short/long/char 等定点数类型(float/double浮点数类型不能使用)

// 00001000

// 00000001

cout << (8>>3) << endl;   //1

应用:

把一个整数的的最低4位设置为0110

cout << "请输入一个整数: " << endl;
cin >> x;
//把x的最低4位清0
x =  x & (~15);
//把x的最低4位设置为0110
x = x | 6;
cout << "x=" << x << endl;

其它运算

算术运算

赋值运算

x = 10;  //把x的值设置为10, 把10写到变量x中。

x = 10 + a;

左边必须是变量  

“优先级”很低，只比 ","（逗号元素符）高。

复合赋值运算

x += 10;       //  x = x + 10

x -= 10;        //  x = x - 10

类的还有： *= ,    /=,  %= 等。

自增自减运算

i++  =>  i = i+1

++i  =>  i = i+1

1. -   =>  i = 1

--i  =>  i = i-1

i = 100;

x = i++;  // x = 100

i = 100;

x = ++i; // x= 101

1.只能对变量做++和--运算，不能对变量和表达式做++和--运算

 5++;  //ERROR

（3+x)++;  //ERRO

2.建议尽量使用前缀自增（自减），以避免错误。

逗号运算符

优先级最低。

#include <stdio.h>
int main(void) {
       int x;
       // 先计算 x = 3+5,  再计算3*5
       x = 3+5, 3*5, 10/5;
       printf("x=%d\n", x);  //x=8
       //取最后一个表达式的值，作为整个“逗号表达式”的值
       x = (3+5, 3*5, 10/5); 
       cout  <<  x  <<  endl; //x=2
       return x;
}

三目运算符

条件 ?  表达式1 ：表达式2

如果条件为真，就取表达式1作为整个表达式的值

如果条件为假，就取表达式2作为整个表达式的值

#include <iostream>
#include <Windows.h>
using namespace std;
int main(void) {
      int salary;
      printf("请输入您的月薪: ");
      scanf("%d", &salary);
      cout <<  (salary > 30000 ? "老鸟" : "菜鸟") << ", 晚上好!" << endl;
      system("pause");
      return 0;
}

使用多个运算符时的优先级

一共有15个级别！

不需强制记忆，只需要掌握以下常用的优先级：

最高优先级：( )和[ ]

最低优先级：逗号表达式

倒数第二低优先级：赋值和复合赋值(=， +=,  -=  ...)

x = a+ b*c;

！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

(3 + 4 < 5  &&  6 > 7)  ||  (8 > 7);