• C语言中的操作符（万字详解）

    C语言中的操作符（万字详解）

    • 🎈个人主页：库库的里昂
    • 🎐CSDN新晋作者
    • 🎉欢迎 👍点赞✍评论⭐收藏
    • ✨系列专栏C语言初阶、代码小游戏
    • 🤝希望作者的文章能对你有所帮助，有不足的地方请在评论区留言指正，大家一起学习交流！🤗

    【前言】

    • 操作符的种类比较多，也是我们在敲代码过程中很常用的知识点，里面有很多重点内容和易错的地方，所以还请大家要十分专注，不要遗漏任何一处！
    • 希望通过这篇博客，你能够有所收获，能够得到进一步的提升，这才是最主要的！下面让我们来一起看一看吧。😉

    一、算术操作符（）

     +    -    *    /    %
加   减   乘   除   余

    • 1
    • 2

    这里重点介绍 / 和 %

    1.除号 /

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

    代码示例：

    #include
int main()
{
	int m = 7 / 2;
	double n = 7.0 / 2.0;
	printf("m=%d\n", m);
	printf("n=%lf\n", n);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    m=3
n=3.500000

    • 1
    • 2

    2.取余 %

    • % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
    • 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

    代码示例：

    #include
int main()
{
	int m = 7 % 2;
	printf("m=%d",m);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    运行结果：

    m=1

    • 1

    二、移位操作符

    左移操作符：<<
    右移操作符：>>

    注：

    • 移位操作符的操作数只能是整数。
    • 对于移位操作符，不要移动负数位，这个是标准为定义的

    代码示例：

    int a = 10;
int b = a >> -2;//error

    • 1
    • 2

    那移位操作符怎么移位的呢？

    其实"位"是指二进制位,所以移位操作符是指移动一个数的二进制位.

    说到二进制数，就不得不提到三种表示形式：原码、补码、反码

    那原码、补码、反码的二进制表示形式是什么呢？

    首先，无论是原码反码还是补码，它们都是由符号位和数值位组成的，一般将最高位作为符号位，用‘0’表示正数，‘1’表示负数。

    1.原码

    正数

    5
二进制表示：00000101
原码：00000000 00000000 00000000 00000101

    • 1
    • 2
    • 3

    负数

    -5
二进制表示：10000101
原码：10000000 00000000 00000000 00000101

    • 1
    • 2
    • 3

    2.反码

    正数的反码和原码相等

    负数：原码除符号位全部变成相反数（0-1）

    -5
反码11111111 11111111 11111111 11111010

    • 1
    • 2

    3.补码

    正数的原码、反码、补码相等

    负数：在反码的基础上加1

    -5
补码：11111111 11111111 11111111 11111011

    • 1
    • 2

    4.左移操作符

    移位规则：
    左边抛弃、右边补0

    正数

    代码示例：

    #include
int main()
{
	int m = 10;
	//原码：00000000 00000000 00000000 00001010
	int n = m << 1;
	printf("n=%d",n);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    n=20

    • 1

    结果分析：

           原码:  00000000000000000000000000001010
移动后的补码:  00000000000000000000000000000101                   0

    • 1
    • 2

    如图所示，m向左偏移1位相当于其原码向左移动一位，移出去的0去掉，在右边补上个0，因为正数的原码、反码、补码相同，所以移位后的补码为0000 0000 00000000 00000000 00010100
    化为十进制数为20

    负数

    代码示例：

    #include
int main()
{
	int m = -10;
	//原码：10000000 00000000 00000000 00001010
	int n = m << 1;
	printf("n=%d",n);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    n=-20

    • 1

    结果分析：

              原码：10000000000000000000000000001010
          反码：11111111111111111111111111110101
          补码：11111111111111111111111111110110
  移动后的补码： 11111111111111111111111111110110               0
          反码：11111111111111111111111111111011
          原码：10000000000000000000000000000100

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    如图所示，m向左偏移1位相当于其原码向左移动一位，移出去的1去掉，在右边补上个0，算得移动后的原码为10000000000000000000000000000100
    化为10进制数是**-20**

    5.右移操作符

    移位规则：

    首先右移运算分两种：
    1. 逻辑移位
    左边用0填充，右边丢弃
    2. 算术移位（常用）
    左边用原该值的符号位填充，右边丢弃

    正数
    逻辑移位

    代码示例：

    #include
int main()
{
	int m = 10;
	//原码：00000000 00000000 00000000 00001010
	int n = m >> 1;
	printf("n=%d",n);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    n=5

    • 1

    结果分析：

           10原码：00000000000000000000000000001010
移动后的补码：  00000000000000000000000000000101     0

    • 1
    • 2

    如图所示，m向右偏移1位相当于其原码向右移动一位，移出去的0去掉，在左边补上个0，因为正数的原码、反码、补码相同，所以移动后的原码为：00000000000000000000000000000101
    化为10进制数是5

    算术移位

    代码示例：

    #include
int main()
{
	int m = 10;
	//原码：00000000 00000000 00000000 00001010
	int n = m >> 1;
	printf("n=%d",n);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    n=5

    • 1

    结果分析：

           10原码：00000000000000000000000000001010
移动后的补码：  00000000000000000000000000000101     0

    • 1
    • 2

    如图所示，m向右偏移1位相当于其原码向右移动一位，移出去的0去掉，在左边补上个0，因为正数的原码、反码、补码相同，所以移动后的原码为：00000000000000000000000000000101
    化为10进制数是5

    总结：正数的逻辑移位和算术移位的结果相等

    负数
    逻辑移位

    代码示例：

    #include
int main()
{
	int m = -10;
	//原码：10000000 00000000 00000000 00001010
	int n = m >> 1;
	printf("n=%d", n);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    n=5

    • 1

    结果分析：

           -10原码：10000000000000000000000000001010
          反码：11111111111111111111111111110101
          补码：11111111111111111111111111110110
  移动后的补码： 01111111111111111111111111111011    0
          反码：01111111111111111111111111111010
          原码：00000000000000000000000000000101

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    如图所示，m向右偏移1位相当于其原码右移动一位，移出去的0去掉，在左边边补上个0，算得移动后的原码为00000000000000000000000000000101
    化为10进制数是5

    算术移位

    代码示例：

    #include
int main()
{
	int m = -10;
	//原码：10000000 00000000 00000000 00001010
	int n = m >> 1;
	printf("n=%d", n);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    n=-5

    • 1

    结果分析：

           -10原码：10000000000000000000000000001010
          反码：11111111111111111111111111110101
          补码：11111111111111111111111111110110
  移动后的补码： 11111111111111111111111111111011    0    
          反码：11111111111111111111111111111010
          原码：10000000000000000000000000000101

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    如图所示，m向右偏移1位相当于其原码右移动一位，移出去的0去掉，在左边边补上个1，算得移动后的原码为10000000000000000000000000000101
    化为10进制数是**-5**

    总结：负数的逻辑移位和算术移位的结果互为相反数

    综上所述：
    算术右移：左边用原该值的符号位填充
    逻辑右移：左边补0
    左移操作符不存在逻辑移位
    VS2019编译环境下支持算术移位

    三、位操作符

    位操作符有：

    &  //按位与
|  //按位或
^  //按位异或

    • 1
    • 2
    • 3

    注！！！
    他们的操作数必须是整数
    同样这里的位也是指二进制位.

    1.按位与操作符：&

    按位与操作符的计算方法：

    1. 只有两边的操作数都为真的时候才为真,否则都为假.
    2. 即二进制对应的位置都为1时取1，否则都为0

    正数

    代码示例：

    #include 
int main()
{
	int num1 = 1;
	int num2 = 2;
	int num3 = num1 & num2;
	printf("num3=%d",num3);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    num3=0

    • 1

    结果分析：

      1补码：00000000000000000000000000000001
  2补码：00000000000000000000000000000010
1&2补码：00000000000000000000000000000000 //0

    • 1
    • 2
    • 3

    2.按位或操作符：|

    按位或操作符的计算方法：
    只要一边为真则为真。
    即二进制对应的位置有1时取1，否则为0。

    代码示例：

    #include 
int main()
{
	int num1 = 1;
	int num2 = 2;
	int num3 = num1 | num2;
	printf("num3=%d",num3);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    num3=3

    • 1

    结果分析：

      1补码：00000000000000000000000000000001
  2补码：00000000000000000000000000000010
1|2补码：00000000000000000000000000000011//3

    • 1
    • 2
    • 3

    3.按位异或操作符：^

    按位或操作符的计算方法：
    相同为假,相异为真。
    即二进制对应位置相同则取0；反之，则为1。

    代码示例：

    #include 
int main()
{
	int num1 = 1;
	int num2 = 2;
	int num3 = num1 ^ num2;
	printf("num3=%d",num3);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    代码结果：

    num3=3

    • 1

    结果分析：

      1补码：00000000000000000000000000000001
  2补码：00000000000000000000000000000010
1|2补码：00000000000000000000000000000011//3

    • 1
    • 2
    • 3

    按位异或操作符推广：实现两个数的交换。（不能创建临时变量）

    代码示例：

    #include 
int main()
{
	int a = 10;
	int b = 20;
	a = a^b;//10^20
	b = a^b;//10^20^20=10^0=10
	a = a^b;//10^20^10=10^10^20=0^20=20
	printf("a = %d b = %d\n", a, b);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    代码结果：

    a=20 b=10

    • 1

    小结：
    异或操作符满足交换律

    四、赋值操作符

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

    代码示例:

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

    • 1
    • 2
    • 3
    • 4

    这里需要注意的是

    1.连续赋值容易使人误解,建议分开赋值

    代码示例：

    int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值

    • 1
    • 2
    • 3
    • 4

    这样的代码感觉怎么样？

    那同样的语义，你看看：

    x = y+1;
a = x;

    • 1
    • 2

    这样的写法是不是更加清晰爽朗而且易于调试。

    2.复合赋值符

    代码示例：

    #include 
int main()
{
	int a = 2, b = 3;
	a += b;//a=a+b
	a -= b;//a=a-b
	a *= b;//a=a*b
	a /= b;//a=a/b
	a %= b;//a=a%b
	a >>= b;//a=a>>b
	a <<= b;//a=a<
	a &= b;//a=a&b
	a |= b;//a=a|b
	a ^= b;//a=a^b
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    五、单目操作符

    1.单目操作符介绍

    !           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符)
(类型)       强制类型转换

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    1.1逻辑反操作：！

    将逻辑结果取反,即真的变为假的,假的变为真的
    在c语言中,0为假,非0为真

    代码示例：

    #include 
int main()
{
	int a = 1;
	int b = 0;
	printf("a=%d\n", !a);//0
	printf("b=%d", !b);//1
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2.2取地址：&

    用于得到变量,数组等的地址
    在C语言中，变量，常量字符串，数组，结构体包括指针等在内存中都是有地址的,需要在内存中分配一块空间来存储这些值,而内存的编号就是内存地址
    但是字面常量（如常数 6）在内存中是没有地址的,因为它本身并不需要在保存下来

    代码示例：

    #include 
int main()
{
	int a = 1;
	printf("%p",&a);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    代码结果：

    0133F800

    • 1

    结果分析：

    确实是取地址

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

    sizeof()用于计算操作数所占空间大小,单位是字节,可以以类型、指针、数组和函数等作为参数。
    返回值类型为unsigned int

    代码示例：

    #include 
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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    代码结果：

    40
10
4
4

    • 1
    • 2
    • 3
    • 4

    结果分析：

    我们知道,在数据类型篇已经了解c语言中各数据类型占用多少字节.
    所以当sizeof(数组名)操作符在计算不同类型的数组的时候.得到的结果不同,为相应数组中元素总>和所占用的字节数.
    当我们在数组传参时,传的是数组首元素的地址,而计算地址的大小只有两种结果

    总结:
    数组名一般表示的是数组首元素的地址,但有两个情况是例外的!
    1.sizeof（数组名）——这里数组名表示的是整个数组,用于计算整个数组所占空间的大小
    2.&数组名-----这里的数组名表示的是整个数组，即这里取的是整个数组的地址
    数组+1:

    1.4按位取反：~

    代码示例：

    #include 
int main()
{
	int a = 7;
	printf("~a=%d", ~7);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    代码结果：

    ~a=-8

    • 1

    结果分析：

     7补码:00000000000000000000000000000111
~7补码:11111111111111111111111111111000
~7反码:11111111111111111111111111110111
~7原码:10000000000000000000000000001000//-8

    • 1
    • 2
    • 3
    • 4

    1.5前置、后置++

    代码示例：

    #include 
int main()
{
	int a = 10;
	int b = 10;
	int x = ++a;//先对a进行自增，再使用a
	int y = b++;//先使用b，再对b进行自增
	printf("x=%d y=%d",x,y);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    代码结果：

    x=11 y=10

    • 1

    1.6前置、后置–

    代码示例：

    #include 
int main()
{
	int a = 10;
	int b = 10;
	int x = --a;//先对a进行自减，再使用a
	int y = b--;//先使用b，再对b进行自减
	printf("x=%d y=%d",x,y);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    代码结果：

    x=9 y=10

    • 1

    六、关系操作符

    >
>=
<
<=
!=    用于测试“不相等”
==    用于测试“相等”

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
    警告：
    在编程的过程中== 和=不小心写错，导致的错误。

    七、逻辑操作符

    &&       逻辑与
||       逻辑或

    • 1
    • 2

    它们分别为两个按位与（&）和两个按位或（|）组成，它们的效果是一样的，但它们的作用对象不同：

    • &&(逻辑与):表示操作符两边的操作符都为’真’是才为’真’,否则都为’假’
    • | | (逻辑或):只要有一个为’真’,则为’真’,否则都为’假’
    • 并不是对二进制位进行运算.

    区分逻辑与和按位与
    区分逻辑或和按位或

    代码示例：

    #include
int main()
{
	int a = 1&2;//0
	int b = 1&&2;//1
	int c = 1|2;//3
    int d = 1||2;//1
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    重点来了！！！

    一道360笔试题：

    例1：
#include 
int main()
{
  int i = 0,a=0,b=2,c =3,d=4;
  i = a++ && ++b && d++;
  printf("a = %d\n b = %d\n c = %d\n d = %d\n i=%d", a, b, c, d,i);
  return 0;
}
例2：
#include 
int main()
{
  int i = 0,a=0,b=2,c =3,d=4;
  i = a++||++b||d++;
  printf("a = %d\n b = %d\n c = %d\n d = %d\n i=%d", a, b, c, d,i);
  return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    代码结果：

    例1：
a=1
b=2
c=3
d=4
i=0
例2：
a=1
b=3
c=3
d=4
i=1

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    结果分析：

    例1

    • a++是后置++,所以表达式a++在使用时是0,故表达式左边结果为假
    • 即整个a++ && ++b && d++;语句为假,不执行后面的++b和d++操作
    • 最后:a自增1(后置++),故结果为,a+1=1,b,c,d值不变

    例2

    • 同样a++是后置++,所以表达式a++在使用时是0,故表达式左边结果为假
    • 但是逻辑与会继续执行表达式++b,则表达式++b的结果为真,则整个表达式
    • a++||++b||d++;的结果为真,并不会继续执行d++
    • 最终:a+1,b+1,d和c不变

    八、条件操作符(三目操作符)

    exp1 ? exp2 : exp3

    当我们要输出两个数的较大数时，通常使用if语句完成：

    #include 
int main()
{
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);
	if (a > b)
	{
		printf("%d", a);
	}
	else printf("%d", b);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    其实我们可以转换为较为简单的写法,条件表达式写法:

    #include 
int main()
{
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);
	a > b ? printf("%d", a) : printf("%d", b);
	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    九、逗号表达式

    exp1, exp2, exp3, …expN

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

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

    代码示例：

    #include
{
	int a = 1;
    int b = 2;
	int c = (a>b, a=b+10, a, b=a+1);
	printf("c=%d",c)
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    代码结果：

    c=13

    • 1

    灵活运用逗号表达式
    逗号表达式实际使用时的妙处:

    #include 
int main()
{
	int a = 3, b = 5, c = 0;
	b=dispose1(a);//函数处理1
	c=dispose2(b);//函数处理2
	while (c > 0)
	{
			//这里是一段业务处理
		b = dispose1(a);//函数处理1
		c = dispose2(b);//函数处理2
	}
	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    改为逗号表达式之后:

    #include 
int main()
{
	int a = 3, b = 5, c = 0;
	while (b = dispose1(a), c = dispose2(b),c > 0)
	{
		//这里是一段业务处理
	}
	return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

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

    1. [ ] 下标引用操作符

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

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

    • 1
    • 2
    • 3

    2. ( ) 函数调用操作符

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

    代码示例：

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    3. 访问一个结构的成员

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

    • 1
    • 2

    代码示例：

    #include 
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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    【最后】

    有关操作符还有最后一个隐式类型转换，因为这部分知识点还是比较重要的，所以我们留到下一篇文章仔细讲解，大家可以订阅我的专栏，这样大家就可以第一时间收到我发的文章啦！

    好了,c语言中,有关操作符的知识就讲到这里了，希望对大家有所帮助！🎉

  • 相关阅读:
    react 入门
    (数论) 扩展gcd
    [go 反射] 函数
    新知实验室TRTC初体验
    HCIP第十一天笔记
    宠物经济：千亿级的孤独生意，如何用智能化玩出新花样？
    vue3中setup的两个参数 props，context (attrs，emit，slots)，vue3中的双向数据绑定自定义事件emit和v-model
    密码即服务-初探vault
    HDL-Bits 刷题记录 04
    2035. 将数组分成两个数组并最小化数组和的差 折半搜索
  • 原文地址：https://blog.csdn.net/m0_68662723/article/details/131997692