C语言之操作符详解

已于 2022-05-10 17:23:57 修改
阅读量568 收藏 1
点赞数
分类专栏： # C语言 文章标签： c语言 开发语言 后端
于 2021-12-06 14:54:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Britney_dark/article/details/121711040
版权
  1. 各种操作符的介绍。
  2. 表达式求值

一. 操作符分类

  • 算数操作符
  • 移位操作符
  • 位操作符
  • 赋值操作符
  • 单目操作符
  • 关系操作符
  • 逻辑操作符
  • 条件操作符
  • 逗号表达式
  • 下标引用、函数调用和结构成员

二. 算术操作符

+            -           *           /           %

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。

3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

三. 移位操作符

其操作的是二进制位，并且操作对象是补码！

<< 左移操作符 

>> 右移操作符   

注：移位操作符的操作数只能是整数。

PS：

        因为涉及到二进位的计算，引入二进制的表示形式，情况如下：

        整数有三种二进制的表示形式

  • 原码
  • 反码
  • 补码

        整数在内存中存储的是补码       

        正整数 —— 原码、反码、补码相同

        负整数 —— 原码、反码、补码不同，需进行计算

int a = 5;//正整数

a为整形，占用4个字节 —> 32个bit

（ 前面不够位，自动补0，第一位为符号位，0表示正数，1表示负数 ）

00000000000000000000000000000101 — 原码

00000000000000000000000000000101 — 反码

00000000000000000000000000000101 — 补码

int a = -5;//负整数

a为整形，占用4个字节 —> 32个bit

10000000000000000000000000000101 — 原码

111111111111111111111111111111111010 — 反码

111111111111111111111111111111111011 — 补码

计算如下：

原码的符号位不变，其他位都按位取反得到的就是反码，反码的二进制+1，得到的就是补码

值得一提的是：

运算和存储使用的是补码，但是打印或者使用的时候使用的是原码的值

1.  左移操作符

位规则：

左边抛弃、右边补0

如下：

int a = 5;
//把a在内存中存储的二进制位向左移动两位
int b = a << 2;//把移动后的赋值给b，但是a未改变
printf("%d\n", b);

2.  右移操作符

移位规则：

首先右移运算分两种：

1. 逻辑移位

        左边用0填充，右边丢弃

2. 算术移位

        左边用原该值的符号位填充，右边丢弃

到底是逻辑右移函数算术右移取决于编译器，但常见的编译器都是算术右移，而正数的逻辑移位和算术移位导致的结果一致

警告⚠ ： 对于移位运算符，不要移动负数位，这个是标准未定义的。

例如：

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

四. 位操作符

其操作的是二进制位，并且操作对象是补码！

位操作符有：

&        按位与

|         按位或

^        按位异或

注：他们的操作数必须是整数。

操作规则：

&        有0则为0，两个为1才是1

|         有1则为1，两个为0才是0

^        相同为0，相异为1

如下：

int a = 3;
int b = -5;

int c = a & b;

printf("%d\n", c);

00000000000000000000000000000011 — 3的补码

111111111111111111111111111111111011 — -5的补码

00000000000000000000000000000011 — 3的补码（3 & -5的结果）

111111111111111111111111111111111011 — -5的补码（3 | -5的结果）

111111111111111111111111111111111000 — -8的补码（3 ^ -5的结果）

练习题：

不能创建临时变量（第三个变量），实现两个数的交换

//第一种方法，只适用于总和在较小的数
a = a + b;
b = a - b;
a = a - b;

//第二种方法，异或
a = a ^ b;
b = a ^ b;//a ^ b ^ b，b ^ b = 0, 0 ^ a = a
a = a ^ b;//a ^ b ^ a, a ^ a = 0, 0 ^ b = b
//核心思想是：当相同的异或时，为0；0异或别的整数时为别的整数

五. 赋值操作符

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

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

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;//连续赋值（不推荐）

同样的语义：
x = y+1;
a = x;
这样的写法更加清晰爽朗而且易于调试。

编译器报的一种错误：左操作数必须是左值

左值，是可以放在等号左边的，一般是一块空间

右值，是可以放在等号右边的，一般是一个值，或者一块空间的内容

 复合赋值符：

+=

-=

*=

/=

%=

>>=

<<=

&=

|=

^=

这些运算符都可以写成复合的效果。

比如：

int x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。

六. 单目操作符

概念：只有一个操作数的操作符

1.  单目操作符介绍 

!           逻辑反操作       （ 把假变真，把真变假，把其他数字变0，把0变1 ）

-           负值        （ 把正数变成负数 ）

+           正值        （对正负数都没什么用）

&           取地址        （ 取出内存中的地址 ）

sizeof      操作数的类型长度（以字节为单位）     

（ 计算操作数类型大小，sizeof()括号内不进行值计算，但是进行类型转换计算 ）

~           对一个数的二进制按位取反        （ 对内存中补码的所有二进制位按位取反 ）

--          前置、后置--        （ 前置先--再使用，后置先使用再-- ）

++          前置、后置++        （ 前置先++再使用，后置先使用再++ ）

*           间接访问操作符 ( 解引用操作符 )        （ 指针常用，参考下面的演示代码 ）

( 类型 )       强制类型转换           （ 强制转换数据类型 ）

何为类型？

将名字去除后即为类型

参考如下代码一：

int a = 10;
//类型为 int

int arr[10] = {0};
//类型为 int [10]

sizeof(int)
//等价于sizeof(a)

sizeof(int [10])
//等价于sizeof(arr)

演示代码：

#include <stdio.h>
int main()
{
 int a = -10;
 int *p = NULL;
 printf("%d\n", !2);
 printf("%d\n", !0);
 a = -a;
 p = &a;
 printf("%d\n", sizeof(a));
 printf("%d\n", sizeof(int));
 printf("%d\n", sizeof a);//可以这样写，除类型以外，括号均可省略
 printf("%d\n", sizeof int);//这样写是错的，放类型时不能省略
 return 0;
}
//++和--运算符
//前置++和--
#include <stdio.h>
int main()
{
    int a = 10;
    int x = ++a;
    //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
    int y = --a;
    //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
    return 0;
}


//后置++和--
#include <stdio.h>
int main()
{
    int a = 10;
    int x = a++;
    //先对a先使用，再增加，这样x的值是10；之后a变成11；
    int y = a--;
    //先对a先使用，再自减，这样y的值是11；之后a变成10；
    return 0;
}

关于sizeof其实我们之前已经见过了，可以求变量（类型）所占空间的大小。

2.  sizeof 和 数组

#include <stdio.h>
void test1(int arr[])//等价于int * arr，所以传的是指针，指针的大小只与平台有关
{
 printf("%d\n", sizeof(arr));//4或者8，指针的大小与平台有关，和数据类型无关
}
void test2(char ch[])
{
 printf("%d\n", sizeof(ch));//4或者8，指针的大小与平台有关，和数据类型无关
}
int main()
{
 int arr[10] = {0};
 char ch[10] = {0};
 printf("%d\n", sizeof(arr));//40
 printf("%d\n", sizeof(ch));//10
 test1(arr);
 test2(ch);
 return 0;
}

七. 关系操作符

关系操作符

>

>=

<

<=

!=       用于测试“不相等”

==      用于测试“相等”

这些关系运算符比较简单，但是我们要注意一些运算符使用时候的陷阱。

警告：

在编程的过程中== 和=不小心写错，导致的错误。

八. 逻辑操作符

（ 双目操作符 ）

逻辑操作符有哪些：

&&        逻辑与

 ||          逻辑或

&& - 左操作数为假，右边不加算

| | - 左操作数为真，右边不计算

区分逻辑与和按位与

区分逻辑或和按位或

（ 逻辑与和逻辑或只关注真假，而按位与和按位或针对二进制位 ）

1 & 2 -----> 0

1 && 2 ----> 1

1 | 2 -----> 3

1 || 2 ----> 1

逻辑与和或的特点参考如下代码：

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;

    i = a++ && ++b && d++;
    //由于a++是先使用后++，导致第一个表达式为假，后面不再执行，输出的值为 1 2 3 4
    
    //i = a++||++b||d++;
    //情况参考如上
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}

九. 条件操作符

（ 三目操作符 ）

exp1 ? exp2 : exp3

十. 逗号表达式

exp1, exp2, exp3, …expN

逗号表达式，就是用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//13


//代码2
if (a =b + 1, c=a / 2, d > 0)

//代码3（伪代码）
a = get_val();
count_val(a);
while (a > 0)
{
         //业务处理
        a = get_val();
        count_val(a);
}

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

十一. 下标引用、函数调用和结构成员

（ 双目操作符 ）

1. [ ] 下标引用操作符

操作数：一个数组名 + 一个索引值

int arr[10];//创建数组

 arr[9] = 10;//实用下标引用操作符，[ ]的两个操作数是arr和9。
//这四者都一样：arr[7] --> * ( arr + 7 ) --> * ( 7 + arr )--> 7[arr]

2. ( ) 函数调用操作符

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

#include <stdio.h>
 void test1()
 {
 printf("hehe\n");
 }
 void test2(const char *str)
 {
 printf("%s\n", str);
 }
 int main()
 {
 test1();            //实用（）作为函数调用操作符，操作数为函数名
 test2("hello bit.");//实用（）作为函数调用操作符，操作数为函数名和参数
 return 0;
 }

3. 访问一个结构的成员

.            结构体 . 成员名

->         结构体指针 -> 成员名

#include <stdio.h>
struct Stu
{
 char name[10];
 int age;
 char sex[5];
 double score;
}；
void set_age1(struct Stu stu)
{
 stu.age = 18;//结构成员访问
}
void set_age2(struct Stu* pStu)
{
 pStu->age = 18;//结构成员访问
}

int main()
{
 struct Stu stu;
 struct Stu* pStu = &stu;//结构成员访问
 
 stu.age = 20;//结构成员访问
 set_age1(stu);
 
 pStu->age = 20;//结构成员访问
 set_age2(pStu);
 return 0;
}

十二. 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。 

1.  隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符型和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度 一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的

负数的整形提升
char c1 = -1;

整形 -1 的二进制位：10000000000000000000000000000001

因为是char类型，只有一个字节八个比特位所以经截断后
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
 

正数的整形提升
char c2 = 1;

整形 1 的二进制位：00000000000000000000000000000001

因为是char类型，只有一个字节八个比特位所以经截断后
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
 

无符号整形提升，高位补0

如下：

//实例1
char b = 5;
//截断
//00000000000000000000000000000101
//00000101 - b

char c = 126;
//截断
//00000000000000000000000001111110
//01111110 - c

//当b和c相加的时候，b和c都是char类型
//表达式计算的是就要发生整形提升
//00000000000000000000000000000101 - b
//00000000000000000000000001111110 - c
//b + c 得到a
//00000000000000000000000010000011 - a
//a经过截断得到
//10000011 - a

char a = b + c;
//10000011 - a
//a经过整形提升
//11111111111111111111111110000011 - a（补码）
//10000000000000000000000001111101 - a（原码）

printf("%d\n", a);//-125
// %d 打印整形，需要整形提升

b和c的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

整形提升的例子:

//实例1
int main()
{
 char a = 0xb6;
 short b = 0xb600;
 int c = 0xb6000000;
 if(a==0xb6)
 printf("a");
 if(b==0xb600)
 printf("b");
 if(c==0xb6000000)
 printf("c");
 return 0;
}

实例1中的a,b要进行整形提升,但是c不需要整形提升

a,b整形提升之后,变成了负数,所以表达式 a==0xb6 , b==0xb600 的结果是假,但是c不发生整形提升,则表 达式 c==0xb6000000 的结果是真

所程序输出的结果是:

c

//实例2
int main()
{
 char c = 1;
 printf("%u\n", sizeof(c));
 printf("%u\n", sizeof(+c));
 printf("%u\n", sizeof(-c));
 return 0;
}

//sizeof()括号内不进行真实计算，但是进行类型转换计算，sizeof()直接计算表达式的类型大小
//所以后面两个即使没计算但是也进行了整形提升



//int a, b;
//a + b;表达式有两个属性：值属性，类型属性
//算出来的值即为值属性，int为类型属性
//即使两个变量类型不同也会在进行类型转换计算后但是不进行值计算，然后计算转换后的类型大小

实例2中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节.

表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节.

2.  算术转换

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

long double

double

float

unsigned long int  

long int

unsigned int

int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

警告：

但是算术转换要合理，要不然会有一些潜在的问题。

float f = 3.14;
int num = f;//隐式转换，会有精度丢失

3.  操作符的属性

复杂表达式的求值有三个影响的因素。

        1. 操作符的优先级

        2. 操作符的结合性

        3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

                                                               操作符优先级

                                                （ 从上到下，优先级由高到低 ）

操作符描述用法示例结果类型结合性是否控制求值顺序
（）聚组（ 表达式 ）与表达式同N/A（无结合性）否
（）函数调用函数调用rexpL-R（从左向右结合）否
[ ]下标引用rexp[rexp]lexpL-R否
.访问结构成员lexp.member_namelexpL-R否
->访问结构指针成员rexp->member_namelexpL-R否
++后缀自增lexp ++rexpL-R否
--前缀自减前缀自减rexpR-L（从右向左结合）否
*间接访问* rexplexpR-L否
&取地址& lexp& lexpR-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否
|位或rexp | rexprexpL-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是

一些问题表达式：

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f

注释：代码1在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。

所以表达式的计算机顺序就可能是：

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

//表达式2
c + --c;

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

//代码3-非法表达式
int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}

表达式3在不同编译器中测试结果：非法表达式程序的结果

值编译器
—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

//代码4
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(); 中我们只能通过操作符的优先级得知：先算乘法， 再算减法。

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

//代码5
#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}
//尝试在linux 环境gcc编译器，VS2013环境下都运行，看结果

Linux环境的结果：

 VS2019环境的结果：

看看同样的代码产生了不同的结果，这是为什么？

简单看一下汇编代码

就可以分析清楚：

在Linux中先把前面两次 ++i 运算了，然后就相加了，再进行第三次 ++i ，最后再加上最后一个

在VS2019中，先把三次 ++i 运算完了才把三个数相加

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

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

Hiland.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
操作符详解
今天的你也辛苦啦！
08-15 385
操作符 1. 算数操作符 + - * / % %操作符的两个操作数必须为整数，返回的是整除之后的余数。 除了%操作符之外，其他的几个操作符可以作用于整数和浮点数。 对于/操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。 2. 移位操作符 >> 右移操作符 << 左移操作符 右移操作符 移位规则： 算术右移 (通常都是)：右边丢弃，左边补原符号位。 逻辑右移：右边丢弃，左边补0。 #include <stdio.h&gt
C语言操作符（总结）
shanghx_123的博客
03-24 2500
操作符 分类： 算术操作符 移位操作符 位操作符 赋值操作符 复合赋值操作符 单目操作符 关系操作符 逻辑操作符 条件操作符 逗号操作符 下标引用、函数调用和结构成员 算术操作符 操作符 功能 ...
C语言的所有操作符系列，操作符给操作数找对象
qq_57780685的博客
04-04 651
c语言中涉及的所有操作符详细讲解，你想要的答案就在里面。没有我讲不到的，只有你学不到。
C语言操作符
God_bless_TYY的博客
04-05 203
C语言操作符：算数操作符   移位操作符   位操作符   赋值操作符   单目操作符   关系操作符   逻辑操作符   条件操作符   逗号操作符   下标引用 、函数调用和结构成员
C语言基础-操作符详解
12-30
C语言基础-操作符详解
C语言操作符.xmind
02-25
附送详解链接https://blog.csdn.net/qq_40893595/article/details/104320367
第5节-操作符详解.pdf
11-23
第5节-操作符详解.pdf
C语言中的操作符优先级的详细介绍
08-29
主要介绍了C语言中的操作符优先级的详细介绍的相关资料,希望通过本文能帮助到大家，大家通过本文能彻底掌握这部分内容，需要的朋友可以参考下
C语言基础语法、分支与循环、操作符详解、函数使用、数组、指针、结构体、使用C语言调试代码、专项练习等.zip
最新发布
04-19
C语言之所以命名为C，是因为C语言源自Ken Thompson发明的B语言，而B语言则源自BCPL语言。 1967年，剑桥大学的Martin Richards对CPL语言进行了简化，于是产生了BCPL（Basic Combined Programming Language）语言。
c语言操作符
shsj46787944的博客
07-28 532
在C语言中，操作符是一种强大的工具，可以用于完成各种计算和逻辑操作。本博客将深入解析C语言中一些常用的操作符技巧，结合实际应用案例和注意事项，帮助读者更好地理解和运用这些操作符，提高代码的效率和可读性。
C语言 操作符
lfm1010123的博客
11-13 383
C语言操作符的基本使用
c语言冒泡排序算法详解
04-28
在上面的代码中，我们首先定义了一个整型数组`array`来存储需要排序的元素，然后使用`sizeof`操作符获取该数组的长度，赋值给`n`变量。接下来，我们使用两个嵌套的`for`循环实现了冒泡排序算法。内层循环用于逐一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hiland.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值