C++基础学习笔记5 - 运算符

运算符？加、减、乘、除？

简单的说：C++ 运算符只有：条件运算符、关系运算符、逻辑运算符、数学运算符、位运算符、自增自减运算符、赋值与自赋值运算符

我们先看赋值运算符：

#include <iostream>

//自赋值运算符

void main()
{
    int a = 1;
    a += 10;//      a = a + 10; a 为 11
    a -= 5; //      a = a - 5;  a 为 6
    a *= 3; //      a = a * 3;  a 为 18
    a /= 2; //      a = a / 2;  a 为 9
    a %= 4; //      a = a % 4;  a 为 1
    a &= 10;//      a = a & 10; a 为 0
    a |= 10;//      a = a | 10;
    a ^= 5;//       a = a ^ 5;
    a <<= 3;//      a = a << 3;
    a >>= 3;//      a = a >> 3;
    
    system("pause");
}

条件运算符：

#include <iostream>

//条件运算符  ? :

/*
    假设 有表达式 A B C  组成条件表达式  A ？ B : C;

    条件运算符的嵌套

    A ? B : C;  B 或者 C 部分 可以再写成 条件表达式

    A ？ (A?B:C) : C;            A ？ B : (A?B:C);
    A ？ (A?B:C) : (A?B:C);
    
    其执行顺序为：
    1）执行A 判断 A的结果 为真 还是 假
    2）如果为真 执行 B语句  A C 等同于没有  只剩下  B;
    3) 如果为假 执行 C语句  A B 等同于没有  只剩下  C;

    主语 B  C 语句 必须是同类型
    比如 如果 B 有返回值 是表达式 那么 C 必须一样
    如果 B 是无返回值的 代码语句 C 也必须一样

    std::cout 就没有返回值    1 + 1 这个表达式 就有返回值
*/

void main()
{
    int a, b;

    a = 10;
    b = 20;

    a > b ? std::cout<<"a 大于 b\n" : std::cout<<"a 小于 b\n";

    //此处为真 那么 A C 部分 等于没有  
    //整个语句相当于  int c = a + 10;
    //所以 是 可以执行的 没有语句错误
    int c =  a < b ? a + 10 : b - 10;

    std::cout<<c<<"\n";

    system("pause");
}

关系运算符：

#include <iostream>

//关系运算符

//关系运算符的结果 是 bool

// ==   !=    >   <   >=   <=

void main()
{
    int a, b;

    bool c;

    //相等判断运算符 ==        A == B;

    //会判断  == 该符号 左右 两边的结果 是否相等
    //如果相等 整个表达式 为 真  否则 为假

    a = 1;
    b = 2;

    c = (a == b);
    // a 的 值为1  b 的值 为2  那么 a 和 b 不相等  a == b为假

    //不相等 判断运算符  !=     A != B
    //判断不相等  只要 A 和 B 不相等 那么 A != B 为真
    // A B 相等  A != B 为假

    c = (a != b);
    //a 值为 1  b 值为 2  不相等 所以  a != b 为真

    //大于判断运算符 >  A > B
    
    //a 值为 1  b 值为 2  a 小于 b 所以  a > b 为假
    c = (a > b);

    //小于判断运算符 <     A < B
    
    //a 值为 1  b 值为 2  a 小于 b 所以  a < b 为真
    c = (a < b);

    //大于等于判断运算符 >=      A >= B
    //只要 满足 大于 或者 等于 其中一个条件  就为真
    
    //a 值为 1  b 值为 2  a 小于 b 所以  a >= b 为假
    c = (a >= b);


    //小于等于判断运算符 <=      A <= B
    //只要 满足 小于 或者 等于 其中一个条件  就为真
    
    //a 值为 1  b 值为 2  a 小于 b 所以  a <= b 为真
    c = (a <= b);

    system("pause");
}

逻辑运算符：

#include <iostream>

//逻辑运算符

void main()
{
    //逻辑 与 运算符 &&
    /*
        假设有表达式 A、B 组成的逻辑表达式 A&&B
        
        该表达式会返回一个bool 结果
        表达式会先 得到 A 的结果 并判断真 假
        如果A 为 真   就继续判断 B的 真 假
        如果B 为 真 那么整个表达式（A&&B） 返回 真
        简单说：
        A为真  B为真  表达式 为真
        A为真  B为假  表达式 为假
        A为假  B将不计算  表达式为 假
    */

    int a;
    int b;

    a = 1;
    b = a-- && a++;
    std::cout<<a<<" "<<b<<"\n";

    a = 1;
    b = --a && a++;
    std::cout<<a<<" "<<b<<"\n";

    //逻辑 或 运算符 ||
    /*
        假设有表达式 A、B 组成的逻辑表达式 A||B
        
        该表达式会返回一个bool 结果
        表达式会先 得到 A 的结果 并判断真 假
        如果A B 有一个 为真 那么 表达式 返回真
        如果A B 都为假 表达式 返回 假
        简单说：
        A为真  B将不计算 表达式 为真
        A为假  B为真  表达式 为真
        A为假  B为假  表达式 为假
    */

    a = 1;
    b = a-- || a++;
    std::cout<<a<<" "<<b<<"\n";

    a = 1;
    b = --a || a++;
    std::cout<<a<<" "<<b<<"\n";

    //逻辑 非  ！
    a = 1;
    b = 0;

    //此处 a的值是1 为真 
    //在 a 的前面 加上 ！ 那么a为假
    //也就是 真变假   假变真
    !a; //结果为假
    !b; //结果为真
    
    system("pause");
}

数学运算符：

#include <iostream>

//加+  减-  乘*     除/ 取余%

void main()
{
    int a = 10;

    int b = 20;

    int c = 30;

    //和原来学习的数学计算方式一样 
    //先 乘除 后 加减  优先计算括号内的
    int d = a + b * c;

    //除法稍有不同 （因为参与计算的变量类型）
    //这里10 / 4 的结果 应该是 2.5
    //但是 由于 10 是 int 类型的常量 4 也是 int 类型
    //的 常量 所以  int / int 结果 也是一个 int
    //所以 这里 10 / 4的结果是 2 小数部分 不做保留
    d = 10 / 4;

    //取余 整数的除法 我们可以看成两个部分  商 和 余
    //比如 15 除以 6 得到的结果就是 2 和 3
    //那么 用除号 / 得到的就是 商  2
    //     用取余 % 得到的就是 余数3

    d = 15 / 6;
    d = 15 % 6;

    system("pause");
}

位运算符：

#include <iostream>

//位运算符

/*
    位运算符的处理 是在二进制位的层面上进行处理的
    位的操作是非常快。
*/

void main()
{
    int a = 12345;
    int b = 67891;
    int c;
    char d; 
    //按位与  &        二进制位 同为1 则 为1  反之为0

    c = a & b;
    //a 0000 0000   0000 0000   0011 0000   0011 1001
    //&
    //b 0000 0000   0000 0001   0000 1001   0011 1111
    
    //同1为1 反之为0

    //c 0000 0000   0000 0000   0000 0000   0011 0001


    //按位或 | ： 二进制位 同为0则为0  反之为1

    c = a | b;
    //a 0000 0000   0000 0000   0011 0000   0011 1001
    //|
    //b 0000 0000   0000 0001   0000 1001   0011 1111
    
    //同0为0 反之为1

    //c 0000 0000   0000 0001   0011 1001   0011 1111

    //按位异或 ^  相同为0  不同为1

    c = a ^ b;
    //a 0000 0000   0000 0000   0011 0000   0011 1001
    //|
    //b 0000 0000   0000 0001   0000 1001   0011 1111
    
    //相同为0  不同为1

    //c 0000 0000   0000 0001   0011 1001   0000 0110

    int a1 = 100;
    int a2 = 1122334;
    int a3 = 5566778;

    a1 = a1 ^ a2;
    a1 = a1 ^ a3;

    a1 = a1 ^ a3;
    a1 = a1 ^ a2;

    //反向异或 可以把数据还原 早起用作数据加密

    //按位取反：~   1变0  0变1
    
    ~c;

    //按位左移:  <<

    c = a << 2;
    //a 0000 0000   0000 0000   0011 0000   0011 1001
    //左移两位 最高位会消失 会添加2个 0 到最后位
    //  00 - 00 0000    0000 0000   0011 0000   0011 1001 + 00
    //      0000 0000   0000 0000   1100 0000   1110 0100

    a = 100;

    c = a << 2; //左移1位相当于 * 2 但是比乘法效率高很多

    //按位右移： >>

    c = a >> 2;
    //a 0000 0000   0000 0000   0011 0000   0011 1001
    //右移两位 最低位会消失 会添加2个 符号位 到最后位
    //也就是说 最高位 如果是1  那么添加的就是1
    //比如 10001100    最高位是1 右移后就是 11 + 100011 - 00
    //     11100011
    //如果是 00001100  最高位是0 则添加0即可
    //移动后 00000011

    c = a >> 2; //右移相当于 除 2

    system("pause");
}

自增自减运算符：

#include <iostream>

//自增自减 运算符

void main()
{
    //自增运算符 ++
    //假设有一个变量 a  
    // ++a 相当于  a = a + 1;
    //计算过后 a 的值 会增加1
    int a = 1;

    int b;
    
    //++a
    //++ 会先计算 然后 会把a 增加后的结果 返回出去
    // b得到的就是 增加后的结果 2
    b = ++a;

    a = 1;

    //a++
    //++在后面 就会 先返回a保存的值 1 b得到的就是 1
    //然后 计算++  a 增加 1 
    b = a++;
    
    //自减运算符 --
    
    a = 1;

    //--a
    //-- 会先计算 然后 会把a 减少后的结果 返回出去
    // b得到的就是 减少后的结果 0
    b = --a;

    a = 1;

    //a--
    //--在后面 就会 先返回a保存的值 1 b得到的就是 1
    //然后 计算--  a 减少 1 
    b = a--;

    system("pause");
}
```