C语言基础5：操作符详解：算术、移位、赋值、单目、关系、逻辑、条件、逗号表达式、下标引用、表达式求值

于 2022-12-05 23:46:41 发布
阅读量725 收藏 1
点赞数 1
分类专栏： C语言基础 文章标签： c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1766855068/article/details/125467952
版权

文章目录

C语言基础5：操作符详解：算术、移位、赋值、单目、关系、逻辑、条件、逗号表达式、下标引用、表达式求值

1. 算术操作符

  常用的算数操作符：+ - * / % 

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
    int a = 9;
    int b = 0;
    double c = 0;
    int e = 0;
    b = 9 / 4;
    c = 9 / 4.0;
    e = 9 % 4;//去模运算，只能用于整数
    printf("b = %d\n", b);
    printf("c = %lf\n", c);
    printf("e = %d\n", e);
    return 0;
}

（1）除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
（2）对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
（3）% 操作符的两个操作数必须为整数。返回的是整除之后的余数。
在这里插入图片描述

2. 移位操作符

  移位操作符，移动的是二进制位，进行左移或者右移操作。
在这里插入图片描述

2.1 左移操作符

移位规则：左边抛弃，右边补0
在这里插入图片描述

2.2 右移操作符

  移位规则：
（1）算术移位：左边用原该值的符号位填充，右边丢弃
（2）逻辑移位：左边用0填充，右边丢弃
在这里插入图片描述
  如果要查看内存，可以使用F10(Fn)打开调试，点击窗口，选择内存，查看内存。
在这里插入图片描述
  通过上面知道了，算术右移和左移，再以下面的程序为例，找到地址a，把光标运行到 int b = a >> 1;行，此时内存搜索框中，搜索&a，就可以发现&a 中存放的是 8个f ，也就是说2^32位全1（1个16进制占用4个比特位空间，也就是是 2^4，那么8个16进制数就占用32个比特空间，也就是2^4^8=2^32 ）.在这里插入图片描述
  因此，当 a 为 -1 时，对a进行算术右移1位，左边符号位补齐，右边丢弃，之后赋值给b，b的结果仍未-1。
在这里插入图片描述
  对于移位运算符，不要移动负数位，这个是标准未定义的。

int num = 1;
num>>-1;//error

3. 位操作符

3.1 位操作符基本介绍

位操作符注释
&按位与，相同为1，不同为0
｜按位或，有1为1，全0为0
^按位异或，相异为1，相同为0

注：他们的操作数必须是整数。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int a = 3;		//011
	int b = 5;		//101
	int c = a & b;	//001
	int d = a | b;	//111
	int e = a ^ b;	//110
	printf("c = %d\n", c);
	printf("d = %d\n", d);
	printf("e = %d\n", e);
	return 0;
}

3.2 不使用其他变量，交换int 变量的值

  交换两个int 变量的值，不能使用第三个变量，即 a = 3 , b = 5 ,交换之后，a = 5 ,b = 3;

3.2.1 通过加法完成数据交换

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int a = 5;
	int b = 3;
	a = a + b; //8
	b = a - b; //8 - 3 = 5
	a = a - b; //8 - 5 = 3
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	return 0;
}

3.2.2 通过 异或操作符 进行交换

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int a = 5;	//101
	int b = 3;	//011
	a = a ^ b;	//110
	b = a ^ b;	//110 ^ 011 = 101
	a = a ^ b;	//110 ^ 101 = 011
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	return 0;
}

  通过上述规律可以发现，异或 、 异或 可以提抵消
3^5^3=5
3^3^5=5
3^5^5=3
在这里插入图片描述

3.3 练习：求一个整数存储在内存中的二进制中1的个数

3.3.1 方法1：倒序取余法

  求一个整数在内存中所占的二进制1的个数，也就是说要知道这个数有多少位占了，比如：
16也就是0001 0000 二进制1所占 1位
15也就是0000 1111 二进制1所占 4位

  综上，那可以对这个数据一直 ÷ 2 ，一旦有余数为1，说明这个数中就有一个1。如果余数为0的话，说明该位为0。

就好比一个十进制 123，如果要得到他每个数：
①求个位：对123%10=3
②求十位：对123 / 10 = 12 然后 12 % 10 = 2
③求百位：对12 / 10 = 1 然后 1 % 10 = 1
这样就求出了每一位数。

  但是这个程序不适用于整数是负数的情况，还需要优化下。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int num = 123;
	int count = 0;//计数
	while (num)
	{
		if (num % 2 == 1)
			count++;
		num = num / 2;
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}

3.3.2 方法2：移位按位与法

  用刚才的123 举例，123 的二进制是：0111 1011，那我们可以用这个数的每一位 与 0000 0001 进行按位与操作，每比较一次，将0000 0001 的二进制数就向左移动一次，然后若按位与结果是1，则计数。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int num = 123;
	int i = 0;
	int count = 0;//计数
	for (i = 0; i < 32; i++)
	{
		if (num & (1 << i))
			count++;
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}

4. 赋值操作符

  赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。

赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值

  复合赋值符号：+=、-=、*=、/=、%=、>>=、<<=、&=、|=、^=

int x = 10;
x = x+10;
x += 10;//复合赋值

5. 单目操作符

单目操作符只有一个操作数

单目操作符注解示例结果
!逻辑反操作a = 1;!a;a = 0
- 负值a = 1;a = -a;a = 5
+ 正值
&取地址int a = 1; int* p = &a;取a的地址放在了指针p里
sizeof操作数的类型长度（以字节为单位）
~对一个数的二进制按位取反
–前置、后置–
++前置、后置++++a;a++;先加后用；先用后加；
* 间接访问操作符(解引用操作符)*p = 2将指针p中所存放的地址存入2的数据
(类型)强制类型转换int a = int(3.14);将浮点数，强制类型转换为整形

5.1 sizeof 详解

  sizeof 用于计算的是变量所占内存空间的大小（Byte）
（1）sizeof 计算各变量所占内存空间的大小
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int a = 1;
	char b = 'B';
	int arr[10] = { 0 };
	int* p = NULL;

	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));

	printf("%d\n", sizeof(b));
	printf("%d\n", sizeof(char));

	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(int [10]));
	printf("%d\n", sizeof(int [5]));

//	printf("%d\n", sizeof a);//error
//	printf("%d\n", sizeof int);//error
	return 0;
}

（2）以下sizeof 存放变量的情况
  a 是短整型变量，用于将 b + 3的和存入进去，存后，a 还是 短整型，所以sizeof 是 2
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	short a = 1;
	int b = 2;
	printf("%d\n", sizeof(a = b + 3));
	printf("%d\n", a);
	return 0;
}

（3）sizeof 函数传参情况
  由于 数组在传参的时候，传的是首元素的第一个地址，地址传过去后，函数接收必须要指针接收，此时 sizeof(arr)的结果就是4或8个字节。
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void test1(int arr[])
{
 printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])
{
 printf("%d\n", sizeof(ch));//(4)
}
int main()
{
 int arr[10] = {0};
 char ch[10] = {0};
 printf("%d\n", sizeof(arr));//(1)
 printf("%d\n", sizeof(ch));//(3)
 test1(arr);
 test2(ch);
 return 0;
}

5.2 按二进制位取反：~

（1）按位取反运算

按位取反，是按二进制位进行取反，0运算后为1，1运算后为0。在这里插入图片描述
（2）对某个数中的某一位取反
假设2进制数：10101，需要把第4位取反变成11101，我们可以通过把 1 左移 3位，然后与该10101 或运算，既可改为11101。
在这里插入图片描述

6. 关系操作符

关系操作符>>=<<=!===
注释大于大于等于小于小于等于不等于等于

7. 逻辑操作符

关系操作符注释示例
&&逻辑与1&&2结果为1
｜｜逻辑或1｜｜2结果为1

需要注意的是要区分&（按位与）、｜（按位或）

举例：以下程序的计算结果是多少呢：

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}

分析：程序运行的时候，按以下顺序①②③运行：
①a ++ ，由于a 先用了，所以运算的时候 a 还是 0，++没有生效
②接着到运算 0 && ++ b了，由于 && 左侧是0 ，因此 ++b 、d++ 不需要运算，结果已经是0 了。
③所以运算过程也只有 a ++了，就是1，其余的均没有运算，也就是1，2，3，4。
在这里插入图片描述
  但是如果上述把 a = 0 改为 a = 1 ,那么结果就会变为2，3，3，5。因为第②步运算的时候，a =1 ，b > 0，表示为真，因此之后的d++ 也会进行运算。
在这里插入图片描述
  修改代码如下，运行结果是多少呢。
在这里插入图片描述
在这里插入图片描述
  答案是：2234，分析，当运算i = a++ || ++b || d++的时候，程序先运行的是 a++ || 当运行到这里的时候就会发现，这个 a 的结果是1，说明为真，那么之后的 ++b、d++ 都不再参与运算，最终结果 只有 a ++ 了一下，也就是 2、2、3、4

8. 条件操作符

若表达式1为真，表达式2的结果为整个表达式的结果，如果表达式1的结果为假，则表达式3的结果为整个表达式的结果。
exp1 ? exp2 : exp3

9. 逗号表达式

exp1, exp2, exp3, …expN

  逗号表达式：就是用逗号隔开的多个表达式。从左向右依次执行，整个表达式的结果是最后一个表达式的结果。
在这里插入图片描述
  逗号表达式的使用举例，可以将程序优化减少啰嗦。

源代码：
a = get_val();
count_val(a);
while (a > 0)
{
         //业务处理
        a = get_val();
        count_val(a);
}


优化：如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
         //业务处理
}

10. 下标引用，函数调用和结构成员操作符

10.1 [ ] 下标引用操作符

对于 加号 而言，1 + 2，1 和 2 就是 加号的两个操作数
对于 数组 而言，arr[10] 方括号的操作数：一个数组名 + 一个索引值
对于 函数 而言， get_max(a,b) ，其中（）式操作符，而操作数是 get_max、a、b。

数组：
int arr[10];//创建数组
 arr[9] = 10;//实用下标引用操作符。
 [ ]的两个操作数是arr和9。

函数：
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
get_max(int x, int y)
{
	return x > y ? x : y; 
}
int main()
{
	int a = 10;
	int b = 20;
	//() 调用函数的时候,()就是函数调用操作符
	int max = get_max(a, b);
	printf("max = %d\n", max);
	return 0;
}

10.2 函数调用

  接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
get_max(int x, int y)
{
	return x > y ? x : y; 
}
int main()
{
	int a = 10;
	int b = 20;
	//() 调用函数的时候,()就是函数调用操作符
	int max = get_max(a, b);
	printf("max = %d\n", max);
	return 0;
}

10.3 结构成员

  在写C语言代码的时候，为了描述一个对象，比如学生会有很多属性，姓名、年龄、学号。对于 int 、float 而言是一种类型，而结构体也是一种类型

操作符注释
.结构体.成员名
->结构体指针->成员名

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
//创建一个名为 student 的结构体
struct student
{
	char name[10];
	int age;
	char id[20];
};
int main()
{
	int a = 10;
	//使用 struct student 这个类型创建了一个学生对象叫做S1，并初始化
	struct student S1 = { "张三", 20, "202010200330" };
	printf("%s\n", S1.name);
	printf("%d\n", S1.age);
	printf("%s\n", S1.id);

	//结构体变量.成员名
	struct student* ps = &S1;
	printf("%s\n", (*ps).name);
	printf("%d\n", (*ps).age);
	printf("%s\n", (*ps).id);

	//结构体指针->成员名
	printf("%s\n", ps->name);
	printf("%d\n", ps->age);
	printf("%s\n", ps->id);
	return 0;
}

11. 表达式求值

  表达式求值的顺序一部分是由操作符的优先级和结合性决定。同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

11.1 隐式类型转换

  C的整型算术运算总是至少以缺省整型类型的精度来进行的。
  为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升.

  整形提升：在我们计算的过程中，我们发现我们的表达式有些操作数的大小达不到一个整形大小的时候，他们会发生整形提升，变成一个整形，然后再参与运算。

如何进行整形提升：首先看变量的类型是什么类型:
①它是有符号数（10000010），则高位就是他的符号位来填充（11111111 11111111 11111111 10000010）
②如果是无符号数，高位直接补0.
例如：
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	char a = 3;
	//00000000 00000000 00000000 00000011
	//00000011 - a

	char b = 127;
	//00000000 00000000 00000000 01111111
	//01111111 - b
	
	//a 和 b 如何相加
	//00000000 00000000 00000000 00000011
	//00000000 00000000 00000000 01111111
	//00000000 00000000 00000000 10000010

	char c = a + b;
	//10000010 - c
	//补码：11111111 11111111 11111111 10000010
	//反码：11111111 11111111 11111111 10000001
	//原码：11111111 11111111 11111111 01111110 - 126

	printf("%d\n", c);
	return 0;
}

整形提升的意义：
  表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
  因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
  通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于 int 长度的整型值，都必须先转换为 int 或 unsigned int，然后才能送入CPU去执行运算。

  举例，定义字符型、短整型、整型的十六进制数，他们在内存中存储的方式如下，只有整数型才能等于整数型，其余的字符型与短整型没法和整型的数相等，所以最终只输出了 c
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	char a = 0xb6;
	short b = 0xb600;
	int c = 0xb6000000;
	if (a == 0xb6)			//11111111 11111111 11111111 10110110
		printf("a");
	if (b == 0xb600)		//11111111 11111111 10110110 00000000
		printf("b");
	if (c == 0xb6000000)	//00000000 00000000 00000000 10110110
		printf("c");
	return 0;
}

  数据在运算的过程中数据类型会变，甚至会发生整型提升。
在这里插入图片描述

11.2 算数转换

  如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

比如 float 和 double 一同运算的时候，需要把 float 的精度转换为double 的精度，之后再进行运算

long double
double
float
unsigned long int
long int
unsigned int
int

11.3 操作符的属性

复杂表达式的求值有三个影响的因素。
（1） 操作符的优先级
（2）操作符的结合性
（3）是否控制求值顺序。
  两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。操作符优先级
表格由上到下分别表示了优先级的由高到低

操作符描述用法示例结果类型结合性是否控制求值顺序
（）聚组（表达式）与表达式同N/A否
（）函数调用rexp（rexp，…,rexp）rexpL-R否
[ ]下标引用rexp[rexp]lexpL-R否
.访问结构成员lexp.member_namelexpL-R否
->访问结构指针成员rexp->member_namelexpL-R否
++后缀自增lexp ++rexpL-R否
–后缀自减lexp –rexpL-R否
!逻辑反! rexprexpR-L否
~按位取反~ rexprexpR-L否
+单目，表示正值+ rexprexpR-L否
- 单目，表示负值- rexprexpR-L否
++前缀自增++ lexprexpR-L否
–前缀自减– lexprexpR-L否
*间接访问* rexplexpR-L否
&取地址& lexprexpR-L否
sizeof取其长度，以字节表示sizeof rexp sizeof(类型)rexpR-L否
(类型）类型转换(类型) rexprexpR-L否
*乘法rexp * rexprexpL-R否
/除法 rexp / rexprexpL-R否
%整数取余rexp % rexprexpL-R否
+加法rexp + rexprexpL-R否
-减法rexp - rexprexpL-R否
<<左移位rexp << rexprexpL-R否
>>右移位rexp >> rexprexpL-R否
> 大于rexp > rexprexpL-R否
>=大于等于rexp >= rexprexpL-R否
<小于rexp < rexprexpL-R否
<=小于等于rexp <= rexprexpL-R否
==等于rexp == rexprexpL-R否
!=不等于rexp != rexprexpL-R否
&位与rexp & rexprexpL-R否
^位异或rexp ^ rexprexpL-R否
｜位或rexprexp rexpL-R否
&&逻辑与rexp && rexprexpL-R是
｜｜逻辑或rexp ｜｜ rexprexpL-R是
? :条件操作符rexp ? rexp : rexprexpN/A是
=赋值lexp = rexprexpR-L否
+=以…加lexp += rexprexpR-L否
-=以…减lexp -= rexprexpR-L否
*=以…乘lexp *= rexprexpR-L否
/=以…除lexp /= rexprexpR-L否
%=以…取模lexp %= rexprexpR-L否
<<=以…左移lexp <<= rexprexpR-L否
>>=以…右移lexp >>= rexprexpR-L否
&=以…与lexp &= rexprexpR-L否
^=以…异或lexp ^= rexprexpR-L否
｜=以…或lexp ｜= rexprexpR-L否
，逗号rexp，rexprexpL-R是
一个这样的表达式：a*b + c*d + e*f，计算机会根据以上的优先级和结合性有多种算法，例如：

a*b
c*d
a*b + c*d
e*f
a*b + c*d + e*f

或者：
a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f

如果式中的a、b、c 为表达式，那么计算之后可能会有不同的问题出现，所以该表达式为问题表达式
因此尽量避免计算机在计算的时候有多种计算方式，而是有唯一的计算路径

c + --c;

注释：同上，操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们并没有办法得
知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义
的。

int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}
值编译器
—128Tandy 6000 Xenix 3.2
—95Think C 5.02(Macintosh)
—86IBM PowerPC AIX 3.2.5
—85Sun Sparc cc(K&C编译器)
—63gcc，HP_UX 9.0，Power C 2.0.0
4Sun Sparc acc(K&C编译器)
21Turbo C/C++ 4.5
22FreeBSD 2.1 R
30Dec Alpha OSF1 2.0
36Dec VAX/VMS
42Microsoft C 5.1
int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少？
     return 0;
}

  虽然在大多数的编译器上求得结果都是相同的。
  但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。

  函数的调用先后顺序无法通过操作符的优先级确定

#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}

  这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序

我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题

Slash · Young
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言中逗号表达式
08-03
本文介绍了C语言中逗号表达式的使用以及原则。
算术操作符
m0_64692923的博客
09-04 262
操作符
算数操作符
我的博客
06-13 233
java的算术操作符 一、常见的算数操作符 加+减-乘*除/求余% 自增++自减 -- 二、练习 练习一、基本算数操作符 package j2se; public class caozuofu { public static void main(String[] args) { int i=10; int j=5; int a=i+j; int b=i-j; int c=i*j; int d=i/j; } } 练习二、求和 使用Scanner从控制台获取两个数字，然后计算这两个数字的和
C语言基础十：移位（菜鸟编程教学10）.mobi
03-31
C语言基础十：移位（菜鸟编程教学10）
C语言基础-操作符详解
12-30
C语言基础-操作符详解
详解C语言中的符号常量、变量与算术表达式
07-30
这篇文章主要介绍了C语言中的符号常量、变量与算术表达式,是C语言入门学习中的基础知识,需要的朋友可以参考下。
关于c语言逗号表达式的运算规则知识点
01-20
c语言逗号表达式的运算规则 c语言逗号表达式是由左向右进行的：k=3*2=6，K+2=8，表达式返回8。 逗号表达式用法： 当顺序点用，结合顺序是从左至右，用来顺序求值，完毕之后整个表达式的值是最后一个表达式的值。 ...
操作符之算术操作符
岁月净好
06-21 276
算术操作符 Java的基本算术操作符与其他大多数程序设计语言是相同的，其中包括加号（+），减号（—），除号（/），乘号（*）以及取模操作符（%，它从整数除法中产生余数）。整数除法会直接去掉结果的小数位，而不是四舍五入地圆整结果。 Java也使用一种来自C和C++的简化符号同时进行运算与赋值操作，这用操作符后紧跟一个等号来表示，它对于Java中的所有操作符都适用，只要其有实际意义就行。例如，要将x加4，并将结果赋回给x，可以这么写：x=4。 下面这个例子展示了各种算术操作符的用法： //:operato
16.算术运算符（操作符）
quanxiaobai_的博客
06-29 134
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>算术运算符（操作符）</title> <script type="text/javascript"> /* 运算符也叫操作符 通过运算符可以对一个或多个值进行运算，并获取运算结果 比如：typeof就是一个运算符，可以来获得一个值的类型
从头认识java-2.2 算术操作符
raylee2007的专栏
10-22 88
这一章节来聊一下算术操作符 1.自动转换结果类型。 package com.ray.ch01; public class Test { public static void main(String[] args) { int a = 2, b = 3; int c = a / b; int d = b / a; System.out.println(c); System...
操作符 算数操作符
qq_42919799的博客
10-20 146
操作符 算数操作符 + - * / % ++ -- /** 任意单元的长度超过int，那么结果就按照最长的长度计算 */ public class year {//类对应的块 public static void main(String[] args) {//主方法对应的块 int a = 5; long b = 6; ...
算术操作符（Mathematical operator）
u011282025的专栏
08-20 787
Java 的基本算术操作符与其他大多数程序设计语言是相同的。其中包括加号（+）、减号（-）、 除号（/）、乘号（*）以及模数（%，从整数除法中获得余数）。整数除法会直接去掉结果的 小数位，而不是四舍五入的进位。 Java 也使用一种简化符号同时进行运算与赋值操作。它用操作符后紧跟一个等号来表示， 这对于 Java 中的所有操作符都适用，只要其有实际意义就行。例如，要将 x 加 4，
java基础-操作符-算术操作符
weixin_41866473的博客
01-02 209
java中的操作符：1.操作符接收一个或多个参数，并生成一个新值； 2.有些操作符可以改变操作数本身的值，这被称为副作用，例如自增，自减操作符，这类带有副作用的操作符 的最普遍的用途就是用来产生副作用。但是使用此类操作符生成的值，与没有副作用的操作符生成的值没有什么区别。 3....
操作符（一）(算数操作符，位移操作符，位操作符)
HanMeng的博客
12-10 1860
目录：1.算术操作符2.位移操作符(1) <<    左移操作符(高位丢掉，低位补0):eg:将1左移1位(2) >> 右移操作符:eg:将1右移一位3.位操作符eg:不创建临时变量（第三个变量），实现两个数的交换 1.算术操作符 + - * / % · 使用方法： (1)%操作符的操作数必须为整数，其余几个操作符可以作用于整数也可以作用于浮点数。 (2)/操作符如果两个操作数都是整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
假设变量已正确定义并赋值，写出满足下列条件的C语言表达式。 ch 是空格或者回车：
最新发布
08-30
当变量已经被正确定义并赋值后，以下是C语言表达式的满足条件的一些情况： 1. 变量名：变量名可以是任何以字母或下划线开头的字符序列，后跟任意字母、数字或下划线的字符序列。 2. 数字常量：数字常量可以是整数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值