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");
}