运算符和表达式

一、基本概念

1、运算符的操作数

​ 当前运算符需要几个数字运算；

2、左值与右值

​ 左值：一般为变量 —— 可修改；

​ 右值：与变量类型相符；

#include <iostream>
using namespace std;

const int max = 1;		//定义MAX为常量
int main()
{
    int i = 2;    
    1 = i;			//报错：表达式必须是可修改的左值
    max = i;		//报错：表达式必须是可修改的左值
    
    system("pause");
    return 0;
}

3、优先级和结合性的概念

​ 优先级：逗号 < 赋值条件 < 位 < 算术运算符 < 括号

​ 结合性：一般 赋值语句 和 位运算 以及 ++ 和 —— 从右往左发

二、基本运算符

1、赋值运算符

#include <iostream>
using namespace std;

int main()
{
    int a = 1;			//将 1 赋值给 a；
    //赋值语句的准则：运算符两边的类型要一致
    //当两边类型不同时，以左边为标准进行强制转换
    int nNum = 1.2;		//报错： 从“double”转换到“int”，可能丢失数据
    
	int* p = NULL;
    int arr[3];
    p = arr;			//报错：间接引用不同
    system("pause");
    return 0;
}

2、算术运算符

加 ’+‘，减 ‘-’, 乘 ‘*’, 除 ‘/’, 取余 ‘%’;

/*
	算数运算符
*/
#include <iostream>
using namespace std;

int main()
{
	int a = 1, b = 2;
    //加，减，乘
    // 不存在简写的形式，例：a(a + b) 错误
    cout<<a + b<<"\t"<<a - b<<"\t"<<a * b;
    
    //除
    int result = a / b;			//结果为整型
    //除法存在自动取整的问题,不存在四舍五入，直接舍去小数部分
    //整型除以整型 => 整型
    //整型 / 浮点型 => 浮点型
    //浮点型 / 浮点型 => 浮点型
    cout<< 1.0 / 2<< endl;		//结果为浮点型
    
    //取余
    //经典案例：颠倒一个三位数： 例: 123 => 321;
    int nNum = 123;
    int num1 = nNum % 10;		//取个位
    int num2 = nNum / 10 % 10;	//取十位
    int num3 = nNuM / 100;		//取百位
    cout<<num1<<num2<<nume3;	//倒序输出
    //取余的正负 ——由被取余数的正负有关系
    cout<< -2 % 3<< endl;		//结果为负
    cout<< 2 % -3<< endl;		//结果为正
    
	system("pause");
    return 0;
}

3、复合赋值运算符

+=，*=，-=，/=；

#include <iostream>
using namespace std;

int main()
{
    int a = 1,b = 2;
    a += b;			//等价于 a = a + b;
    a *= b;			//等价于 a = a * b;
    
    system("pause");
    return 0;
}

4、条件运算符

条件表达式和逻辑表达式的值只有两个： 0 或 1；

1 表示成立，0 表示不成立；

计算机中，所有非零值均为真，零均为假

/*
	条件表达式
*/
#include <iostream>
using namespace std;

int main()
{
    cout<< 1 > 2;		//表达式为假，输出 0；
    cout<< 2 < 3;		//表达式为真，输出 1；
    //表达式不存在连续操作
    cout<< 1 < 2 < 3;	//错误
    
    return 0;
}

5、逻辑运算符

&& 并且，|| 或者，！ 取反；

#include <iostream>
using namespace std;

int main()
{
    //&& ： 表达式1 && 表达式2，当表达式1、2均为真时，整个表达式才为真
    cout<< 2 > 1 && 3 > 1;		//两边都为真，输出 1；
    cout<< 2 < 1 && 3 > 1;		//只要有一边为假，表达式就为假，输出 0；
    
    //|| ： 表达式1 || 表达式2，当表达式1、2 只要有一个为真时，整个表达式就为真
    cout<< 2 > 1 && 3 < 1;		//一边为真，一边为假，表达式为真，输出 1；
    cout<< 2 < 1 && 3 < 1;		//两边都为假，表达式为假，输出0；
    
    //！ ：真变为假，假变为真
    cout<< !3;					//3 为真，表达式为假，输出 0；
    cout<< !0;					//0 为假，表达式为真，输出 1；
    
    system("pause");
    return 0;
}

6、短路现象（机智的计算机）

表达式1 && 表达式2 ，当表达式1为假时，整个表达式即为假，计算机不会再去编译表达式2；

表达式1 || 表达式2，当表达式1为真时，整个表达式即为真，计算机不会再去编译表达式2；

三、特殊运算符

1、三目运算符

/*
	三目运算符
	表达式1 ？ 表达式2 ： 表达式3；		
	解释：如果表达式1 为真，那么整个表达式为表达式2，否则整个表达式为3；
*/

#include <iostream>
using namespace std;

int main()
{
    int result;
    result = 1 > 2 ? 1 : 2;			//表达式1 为假，所以，result 赋值为2；
    int max;
    1 > 2 ? (max = 1) : (max = 2);		//表达式1 为假，所以，max 被赋值为 2；
    return 0；
}

2、逗号运算符

/*
	取逗号表达式的最后一部分
*/

#include <iostream>
using namespace std;

int main()
{
	cout << (1, 2, 3, 4, 5) << endl;		//括号中的值取逗号运算符的最后一个，所以表达式值为 5
	int nNum; 
	nNum = 1, 2, 3, 4, 5;					//由于逗号运算符的优先级最低，赋值运算符 = 先与 1 结合，											所以 nNum 的值为 1；
	cout << nNum << endl;
	nNum = (1, 2, 3, 4, 5);					//先运算括号中的，再与赋值运算符结合，所以 nNum 的值为5；
	cout << nNum << endl;
	return 0;
}

3、自增，自减

/*
	++：a++ 解释为 a=a+1；
	--：a-- 解释为 a=a-1；
	
	前置：++a，先自增，再去用
	后置：a++，先用，再去自增
*/

#include <iostream>
using namespac std;

int main()
{
    int a;
    cout<<a++<<endl;		//先输出 a 的值 0，a 再自增
    cout<<a<<endl;			//a 自增后的值为 1；
    cout<<++a<<endl;		//a 先自增，然后再输出 a 的值 3；
    cout<<a<<endl;			//a 的值为3；
    return 0;
}

4、sizeof()运算符

/*
	用于计算当前变量所占用字节数
	注意点：在编译期完成
*/

#include <iostream>
using namespace std;

int main()
{
  	sizeof(int); 				//计算 int 型所占用的字节数；
    cout<<sizeof(int)<<endl;	//int 型占用的字节数为4；
    //注意项
    int i = 0;
    cout<<sizeof(i++)<<endl;	//sizeof()在编译期进行运算，i的值不会发生改变
    							//c 的运行顺序：编辑 =>编译 => 链接 => 运行
    return 0;
}

四、位运算

1、或 | ：

有一个 1 即为 1；

2、异或 ^：

相同为 1，不同为 0；

3、与 & ：

两个都为 1 ，才为 1；

4、取反 ~ ：

1 变 0，0 变 1，且计算出来的一个数为补码 ，符号位不变，将其转换为 10 进制

5、左移 <<：

​ 右端补0；

6、右移 >>：

右端舍去；