AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C语言之操作符详解篇

2024-02-26 71
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C语言之操作符详解篇


操作符

//算术操作符    +   -  *  /  %
//移位操作符    <<     >> 
//位操作符      &      |          ^   
//赋值操作符    =
//复合赋值符    +=  -=  *=  /=  %=  >>=  <<=  &=  |=  ^=  
//单目操作符    ！   -   +   &   sizeof    ~  --   ++  *  (类型)
//关系操作符    >   >=   <   <=   !=      ==
//逻辑操作符    &&   ||
//条件操作符    exp1 ? exp2 : exp3
//逗号表达式    exp1, exp2, exp3, …expN
//下标引用      [ ] 下标引用操作符
//函数调用      ( ) 函数调用操作符
//结构成员       .   结构体.成员名      -> 结构体指针->成员名    
//二进制操作符    >>  <<   &  |  ^  ~
%d          是十进制的形式打印有符号整型
%u          是十进制的形式打印无符号整型
//给编译器一个数，%d,%u自己当成了有符号和无符号，不存在看原来创建的变量是有符号还是无符号。
%s          是打印字符串
%c          是打印字符
%p          是打印地址
%fl %f      是打印浮点型
% .2 lf     是保留二位小数
% .3 lf     是保留三位小数

二进制

在内存中，对于存储一个整数需要4个字节，也就是32个比特位。

一个整数写出二进制序列的时候，就是32个比特位。

有符号整数：最高位就是符号位。符号位是1，则表示负数。符号位是0，则表示正数。

无符号整数(unsigned int)：没有符号位，所有位都是有效位。

无符号整数一般放置都是正数，表示正数，所以一般原码，反码，补码相同。

但是非要放置负数，按照负数的原码 反码 补码来计算。不妨碍放负数。

0：+0和-0

在内存中，整数的二进制表示形式有3种：原码，反码，补码。

对于正的整数：原码，反码，补码相同，无需计算。

对于负的整数：原码，反码，补码是需要计算的。

原码：按照数值的正负，直接写出的二进制序列就是原码。

反码：原码的符号位不变，其他位按位取反。

补码：反码的二进制 +1 就是得到补码。

整数在内存中的存储的都是补码的二进制序列。

整数在计算的时候使用的是补码的二进制序列。

原码，反码，补码相互转换：

计算机采用的就是一直取反+1的这条线路。 

//10：
原码：00000000000000000000000000001010
反码：00000000000000000000000000001010
补码：00000000000000000000000000001010
//-10
原码：10000000000000000000000000001010
反码：11111111111111111111111111110101
补码：11111111111111111111111111110110

算数操作符

+      -       *     /    %

  • 除了%操作符之外，其他的几个操作符可以作用于整数和浮点数。
  • 对于 / 操作数如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
  • %操作符的两个操作数必须为整数。返回的是整数之后的余数。

在前面初识C语言中我们重点介绍 / 和 %，这里再回顾一下。

整数除法

//整数除法
#include<stdio.h>
int main()
{
  int m = 7 / 2;
  int x = 7.0 / 2;
  int y = 7.0 / 2.0;
  double n = 7 / 2;
  printf("m=%d\n", m);
  printf("x=%d\n", x);
  printf("y=%d\n", y);
  printf("n=%f\n", n);
  return 0;
}

整数除法：两端的操作数整数和浮点数均可。

存放到的变量类型 整数和浮点数 均可(浮点数会有小数位）。

在打印中选择相应的字符和变量类型对齐。

小数除法

//小数除法
#include<stdio.h>
int main()
{
  double m = 7.0 / 2;
  double b = 7 / 2.0;
  double n = 7.0 / 2.0;
  printf("m=%lf\n", m);
  printf("b=%lf\n", b);
  printf("n=%lf\n", n);
  return 0;
}

小数除法： 两端操作数必须至少有一方为小数，才可以得到小数。

运算的小数要放到浮点类型的变量里。

打印的小数所对应的printf所需字母是浮点类型的。

取余(取模)

//取模取余
#include<stdio.h>
int main()
{
  int  n = 7%2;
  printf("n=%d\n", n);
  return 0;
}

取模(取余)：

两端操作数必须均为整数。

得到的结果要放到整形的变量中去。

移位操作符

<<   左移操作符

>>   右移操作符

  • 移位操作符移动的是二进制的位
  • 移位操作符的操作数必须是整数
  • 左移操作符>> 移位规则：左边抛弃，右边补0
  • 右移操作符<< 移位规则：

                     逻辑移位：左边用0填充，右边丢弃

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

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

  • 移位操作符的应用：可以移动你想要的位上去，改变数值。

<<   左移操作符

正数 
//正数
#include<stdio.h>
int main()
{
  int m = 7;
  int n = m << 1;
  printf("%d\n", m);
  printf("%d\n", n);
  return 0;
}

运算如下：

负数 
//负数
#include<stdio.h>
int main()
{
  int m = -7;
  int n = m << 1;
  printf("%d\n", m);
  printf("%d\n", n);
  return 0;
}

运算如下：

总结

左移操作符 移位规则：

左边抛弃，右边补0。（有一个*2的效果）

整数在内存中的是二进制，计算时是二进制的补码，转化成十进制是二进制的原码。

正数原码反码补码均相等。

负数反码补码均需要计算。

>>   右移操作符

正数 
//正数
#include<stdio.h>
int main()
{
  int a = 10;
  int b = 10 >> 1;
  printf("%d\n", a);
  printf("%d\n", b);
  return 0;
}

运算如下：

负数 
//负数
#include<stdio.h>
int main()
{
  int a = -10;
  int b = -10 >> 1;
  printf("%d\n", a);
  printf("%d\n", b);
  return 0;
}

VS编译器采用的是算数移位，绝大多数编译器均采用的是算数移位！

逻辑移位运算

算数移位运算

总结

右移操作符 移位规则：

  • 逻辑移位   左边用0填充，右边丢弃。（负数符号改变，/2的效果）
  • 算数移位   左边用原改值得符号位填充，右边丢弃。（/2的效果）

对于正数，逻辑和算数移位均达到相同的效果/2，原码补码反码相同无需计算均相等。

对于负数，逻辑移位改变正负，移位不改变。同时，都有/2效果，原码反码补码需计算。

位操作符

  • &      按位与

                          对应的二进制位上，只要有0则为0，两个同时为1才为1。

  • |        按位或

                        对应的二进制位上，只要有1则为1，两个同时为0才为0。

  • ^       按位异或

                         对应的二进制位上，相同为0，相异为1。

  1. 位操作符的两个操作数必须为整数。
  2. 位操作数的运算是在二进制的补码基础上运算。

&与

//计算3&-5       
           //00000000 00000000 00000000 00000 011   //3原码补码反码
       //10000000 00000000 00000000 00000 101   //-5原码
       //11111111 11111111 11111111 11111 010   //-5反码
       //11111111 11111111 11111111 11111 011   //-5补码
       //00000000 00000000 00000000 00000 011   //3原码补码反码
       //00000000 00000000 00000000 00000 011   //3补码反码原码
//&与——在对应的二进制位上，只要有0则为0，两个同时为1才为1
#include<stdio.h>
int main()
{
  int a = 3;
  int b = -5;
  int c = a & b;
  printf("%d", c);
  return 0;
}

| 或

//计算3|-5
//00000000 00000000 00000000 00000 011   //3原码补码反码
//10000000 00000000 00000000 00000 101   //-5原码
//11111111 11111111 11111111 11111 010   //-5反码
//11111111 11111111 11111111 11111 011   //-5补码
//00000000 00000000 00000000 00000 011   //3原码补码反码
//11111111 11111111 11111111 11111 011   //补码
//11111111 11111111 11111111 11111 010   //反码
//10000000 00000000 00000000 00000 101   //原码 -5
//|或——在对应的二进制位上，只要有1则为1，两个同时为0才为0
#include<stdio.h>
int main()
{
  int a = 3;
  int b = -5;
  int c = a | b;
  printf("%d", c);
  return 0;
}

^异或 

//计算3^-5
//00000000 00000000 00000000 00000 011   //3原码补码反码
//10000000 00000000 00000000 00000 101   //-5原码
//11111111 11111111 11111111 11111 010   //-5反码
//11111111 11111111 11111111 11111 011   //-5补码
//00000000 00000000 00000000 00000 011   //3原码补码反码
//11111111 11111111 11111111 11111 000   //补码
//11111111 11111111 11111111 11110 111   //反码
//10000000 00000000 00000000 00001 000   //原码 -8
//两个重要点
//a^a=0
//0^a=a
//支持交换律
//^异或——相同为0，相异为1
#include<stdio.h>
int main()
{
  int a = 3;
  int b = -5;
  int c = a ^ b;
  printf("%d", c);
  return 0;

练习

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

2.编写代码实现：求一个整数存储在内存中的二进制中1的个数。（后面讲解，可以先动手写一写，小脑瓜子想想）

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

在前面的初识C语言和函数中，我们已经知晓如下方法： 

//创建临时变量
#include<stdio.h>
int main()
{
  int a = 3;
  int b = 5;
  int c = 0;//创建中间变量
  printf("a=%d b=%d\n", a, b);
  c = a;
  a = b;
  b = c;
  printf("a=%d b=%d", a, b);
  return 0;
}
//函数
#include<stdio.h>
void change(int* a, int* b)
{
  int tmp = 0;
  tmp = *a;
  *a = *b;
  *b = tmp;
}
int main()
{
  int a = 3;
  int b = 5;
  printf("a=%d b=%d\n", a, b);
  change(&a,&b);
  printf("a=%d b=%d", a, b);
  return 0;
}

那如果我们不创建临时变量呢？

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

以上这个加减方法存在缺陷，变量的值如果太大就出现了问题，会超出整形所容纳的范围。         还有没有其他方法呢？

#include<stdio.h>
int main()
{
  int a = 3;
  int b = 5;
  printf("a=%d b=%d\n", a, b);
  a = a ^ b;//3^5
  b = a ^ b;//3^5^5=3
  a = a ^ b;//3^5^3=5(支持交换律）
  printf("a=%d b=%d", a, b);
  return 0;
}

以上异或的方法

优点：不会溢出。

缺点：效率不高，只适用整形，可读性差，因此不建议使用。

赋值操作符

赋值操作符是一个很棒的操作符！🙂🙂在变量创建好了之后，我们将其修改成自己满意的值。

#include<stdio.h>
int main()
{
  int a = 3;//不是赋值是初始化
  a = 4;//赋值
  return 0;
}

连续赋值

赋值操作符可以连续使用，如下： 

#include<stdio.h>
int main()
{
  int a = 10;
  int x = 0;
  int y = 20;
  a = x = y + 1;//连续赋值，从右往左依次赋值
  return 0;
}

连续赋值虽然缩短代码，达到了简练的效果。但是它的可读性很差，不易于调试，建议应该分开。

//连续赋值
a=x=y+1;
//非连续更加清爽
x = y+1;
a = x;

复合赋值 

#include<stdio.h>
int main()
{
  int a = 10;
  a = a << 1;
  a <<= 1;
  int b = 7;
  b = b >> 1;
  b >>= 1;
  return 0;
}

单目操作符

单目操作符指的就是只有一个操作数。

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

！

！逻辑反操作符：

把真的变成假的，把假的变成真的。 

//!
#include<stdio.h>
int main()
{
  int a = 0;
  int flag = !a;
  printf("%d\n", flag);
  if (!a)//表达式为真 才打印
  {
    printf("haha\n");
  }
  return 0;
}

-和+

+正值：没有什么具体的意义。

- 负值： 改变数值的符号。正变负，负变正。 

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

&和*

& 取地址：int* p=&a;（需要存放到指针变量里去）

*  解引用操作符：

*p 对p进行解引用操作，*p是通过p中存放的地址，找到p指向的对象。*p其实是a。

#include<stdio.h>
int main()
{
  int a = 10;
  int* p = &a;//a变量的地址
  printf("%p\n", &a);
  printf("%d", *p);//*p=a
  int arr[10] = {1,2,3,4,5};
  int(*pa)[10] = &arr;//数组的地址
  return 0;
}

sizeof

  •  sizeof 是在计算类型创建变量或者变量的大小，单位是字节。
  •  sizeof 计算的结果是size_t 类型的
  •  sizeof 后面的括号在括号中写的不是类型的时候，括号可以省略。说明sizeof不是函数
  •  sizeof 是操作符（单目操作符），不是函数，函数不能省略括号。
  •  sizeof在计算字符串数组的元素个数时，需要计算"\0"
  • size_t 是无符号整型的
  • size_t类型的数据 进行打印 ，可以使用%zd
//sizeof
#include<stdio.h>
#include<string.h>
int main()
{
  int a = 10;
  printf("%d\n", sizeof(a));
  printf("%d\n", sizeof(int));
  printf("%d\n", sizeof a);//4
  int arr[10] = { 0 };
  printf("%d\n", sizeof(arr));
  printf("%d\n", sizeof(arr[0]));
  printf("%d\n", sizeof(arr) / sizeof(arr[0]));
  char arr1[] = "abcde";
  printf("%d\n", sizeof(arr1));
  printf("%d\n", strlen(arr1));
  return 0;
}

~

~对一个数的二进制按位取反。

#include<stdio.h>
int main()
{
  int a = 0;
  printf("%d", ~a);
  return 0;
}
//00000000 00000000 00000000 00000000
//11111111 11111111 11111111 11111111 补码
//11111111 11111111 11111111 11111110 反码
//10000000 00000000 00000000 00000001 原码-1

--和++

  • ++前置：先+1，再使用
  • 后置++：先使用，后+1
  • --前置：先-1，再使用
  • 后置--：先使用，后-1
  • ++操作符是一种自增1的操作
  • - - 操作符是一种自减1的操作

（谁在前面，就先进行什么操作）

后置++的一个规则：先行性赋值操作。

*dest++ = *src++

两个指针先使用 * 和 = ，再去++

#include<stdio.h>
//++ 前置++ 后置--
//-- 前置-- 后置--
int main()
{
  int a = 7;
  int b = a++;//后置a++  口诀：先使用，后+1
 //相当于b=a   a=a+1
  printf("a=%d b=%d\n",a,b);//8  7
  return 0;
 
}
 
int main()
{
  int a = 7;
  int b = ++a;//前置++a   口诀：先+1，再使用
  //相当于a=a+1   b=a
  printf("a=%d\n", a);//8
  printf("b=%d\n", b);//8
  return 0;
}
 
 
 
int main()
{
  int a = 7;
  int b = a--;//后置a--  口诀：先使用，后-1
 //相当于b=a   a=a-1
  printf("a=%d b=%d\n",a,b);//6 7
  return 0;
 
}
 
int main()
{
  int a = 7;
  int b = --a;//前置--a  口诀：先使用，后-1
 //相当于a=a-1 b=a
  printf("a=%d b=%d\n",a,b);//6 6
  return 0;
 
}

（类型）

（类型） 强制类型转换

不到不得已的情况下，不要使用。强扭的瓜毕竟不甜。最好是设置类型匹配的变量。

#include<stdio.h>
int main()
{
  int a = (int)3.14;
  //3.14被编译器识别为double类型
  //time_t——>unsigned int 
  srand((unsigned int)time(NULL));
  rand();
  //生成随机数
  return 0;
}

练习

#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;
}
//问：
//（1）、（2）两个地方分别输出多少？40 10
//（3）、（4）两个地方分别输出多少？4   4/8  8
  • （1）sizeof(arr)计算的是arr数组全部的大小，数组存放了10个元素的整形，                           一个整型大小是4所以是40
  • （2）sizeof（ch)计算的是ch数组全部的大小，数组存放了10个元素的字符型，                       一个字符型大小是1所以是4
  • （3）test1  test2函数调用，传arr过去，本质上是把数组的首地址传过去，指针接收。            无论是整型，字符型的地址，均是一个指针变量（地址），大小相等。（4/8）
指针变量是用来存放地址的
指针变量的大小，就取决于存放一个地址需要多大的空间
在32位的环境下：
一个地址大小是32bit位，需要4个字节。所以不管什么类型的指针变量，大小都是4个字节。
在64位的环境下：
一个地址大小是64bit位，需要8个字节。所以不管什么类型的指针变量，大小都是8个字节。
综上：指针大小在32位平台是4个字节，64位平台是8个字节。
不要在门缝里看指针，把指针看扁了。不管是什么类型的指针都是4/8个字节的。

关系操作符

这些关系操作符都是 用来 测试两边操作数的大小关系。

特别注意：在编程的过程中==和=不小心写错，导致错误。（辨析）

逻辑操作符

  • &&             逻辑与       并且：操作数有一方为假，都为假。只有双方都为真，才为真。
  •  | |               逻辑或       或者：操作数有一方为真，则为真。只有双方都为假，才为假。

#include<stdio.h>
int main()
{
  //3~5月春季
  int a = 0;
  scanf("%d", &a);
  if (a >= 3 && 5 >= a)
    printf("春天");
   //12或1或2 都是冬天
  if (a == 12 || a == 1 || a == 2)
    printf("冬天");
  return 0;
}

这里还有一道练习题，动手写一写。

#include <stdio.h>
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\nd = %d\n", a, b, c, d);
  return 0;
}
#include <stdio.h>
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\nd = %d\n", a, b, c, d);
  return 0;
}
//程序输出的结果分别是什么？
//提示：&&  左边操作数如果为假，右边无需计算。
//     ||   左边操作数如果为真，右边无需计算。

如果把a初始化值换成1，结果又是怎样呢？（后面操作符题讲解🆗🆗）

条件操作符

exp1?exp2:exp3

有三个操作数，是三目操作符

将下面两端代码改写成条件操作符。

//练习1
#include<stdio.h>
int main()
{
  int a = 0;
  int b = 0;
  scanf("%d", &a);
  if (a > 5)
    b = 3;
  else
    b = -3;
  printf("%d", b);
  return 0;
}
//练习2
#include<stdio.h>
int main()
{
  int a = 0;
  int b = 0;
  int m = 0;
  scanf("%d %d", &a,&b);
  if (a > b)
    m = a;
  else
    m = b;
  printf("%d", m);
  return 0;
}

修改后

//练习1
#include<stdio.h>
int main()
{
  int a = 0;
  int b = 0;
  scanf("%d", &a);
  b = (a > 5 ? 3 : -3);
  printf("%d", b);
  return 0;
}
//练习2
#include<stdio.h>
int main()
{
  int a = 0;
  int b = 0;
  int m = 0;
  scanf("%d %d", &a, &b);
  m = (a > b ? a : b);
  printf("%d", m);
  return 0;
}

逗号操作符

exp1,exp2,exp3,.......expN

  • 逗号表达式，就是用逗哈隔开的多个表达式。
  • 逗号表达式，从左向右依次执行。（依次计算，前面的表达式会影响后面）。
  • 整个表达式的结果是最后一个表达式的结果。
//练习1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
c是多少？
//13
//练习2
a = get_val();
count_val(a);
while (a > 0)
{
    //业务处理
    a = get_val();
    count_val(a);
}
//改写成逗号表达式
//如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
    //业务处理
}

注意：不能因为最后一个表达式起决定性作用就不计算前面的表达式，前面的表达式很有可能影响最后的表达式。

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

下标引用

[ ]下标引用操作符

操作数：一个数组名和一个索引值。 

#include<stdio.h>
int main()
{
  int arr[5] = { 1,2,3,4,5 };
  //             0 1 2 3 4 索引值
  printf("%d", arr[2]);//操作数arr和2
  return 0;
}

函数调用

( )函数调用操作符

接受一个或者多个操作数。第一个操作数是函数名，剩余的操作数就是传递给函数的参数。（函数调用操作符至少有1个操作数） 

#include <stdio.h>
void test1()
{
  printf("hehe\n");
}
void test2(int a,int b)
{
  printf("%d\n", a+b);
}
int main()
{
  test1();    
  test2(3,5);//实用（）作为函数调用操作符。
  return 0;
}

结构体成员

. 结构体.成员名

-> 结构体->成员名

#include<stdio.h>
struct Book
{
  char name[20];
  int price;
};
void Print(struct Book* pb)//结构体指针变量
{
  printf("%s %d\n", (*pb).name, (*pb).price);
  printf("%s %d\n", pb->name, pb->price);
}
int main()
{
  struct Book b = { "C语言",55 };
  printf("%s %d\n", b.name, b.price);
  Print(&b);
  return 0;
}

✔✔✔✔✔最后，感谢大家的阅读，有任何错误和不足，欢迎指正！！！！

代码-------------------→【gitee：https://gitee.com/TSQXG】

联系--------------------→【邮箱：2784139418@qq.com】

文章标签：
云数据库 ClickHouse
C语言
存储
编译器
C++
索引
关键词：
C语言操作符
唐唐思
目录
相关文章
LuckiBit
|
30天前
|
存储 网络协议 C语言
【C语言】位操作符详解 - 《开心消消乐》
位操作符用于在位级别上进行操作。C语言提供了一组位操作符，允许你直接操作整数类型的二进制表示。这些操作符可以有效地处理标志、掩码、位字段等低级编程任务。
LuckiBit
83 8
LuckiBit
|
30天前
|
C语言
【C语言】逻辑操作符详解 - 《真假美猴王 ! 》
C语言中有三种主要的逻辑运算符：逻辑与（`&&`）、逻辑或（`||`）和逻辑非（`!`）。这些运算符用于执行布尔逻辑运算。
LuckiBit
71 7
半截诗
|
5月前
|
存储 C语言 索引
【C语言篇】操作符详解（下篇）
如果某个操作数的类型在上⾯这个列表中排名靠后，那么⾸先要转换为另外⼀个操作数的类型后执⾏运算。
半截诗
89 0
半截诗
|
5月前
|
程序员 编译器 C语言
【C语言篇】操作符详解（上篇）
这是合法表达式，不会报错，但是通常达不到想要的结果， 即不是保证变量 j 的值在 i 和 k 之间。因为关系运算符是从左到右计算，所以实际执⾏的是下⾯的表达式。
半截诗
311 0
ephemerals__
|
3月前
|
存储 缓存 C语言
【c语言】简单的算术操作符、输入输出函数
本文介绍了C语言中的算术操作符、赋值操作符、单目操作符以及输入输出函数 `printf` 和 `scanf` 的基本用法。算术操作符包括加、减、乘、除和求余，其中除法和求余运算有特殊规则。赋值操作符用于给变量赋值，并支持复合赋值。单目操作符包括自增自减、正负号和强制类型转换。输入输出函数 `printf` 和 `scanf` 用于格式化输入和输出，支持多种占位符和格式控制。通过示例代码详细解释了这些操作符和函数的使用方法。
ephemerals__
58 10
是店小二呀
|
3月前
|
存储 编译器 C语言
【C语言】简单介绍进制和操作符
【C语言】简单介绍进制和操作符
是店小二呀
210 1
徐霞客320
|
3月前
|
存储 编译器 C语言
初识C语言5——操作符详解
初识C语言5——操作符详解
徐霞客320
193 0
chian-ocean
|
5月前
|
C语言
C语言操作符（补充+面试）
C语言操作符（补充+面试）
chian-ocean
50 6
温轻舟
|
5月前
|
存储 编译器 C语言
十一：《初学C语言》— 操作符详解（上）
【8月更文挑战第12天】本篇文章讲解了二进制与非二进制的转换；原码反码和补码；移位操作符及位操作符，并附上多个教学代码及代码练习示例
温轻舟
65 0
十一：《初学C语言》— 操作符详解（上）
温轻舟
|
6月前
|
C语言
五：《初学C语言》— 操作符
本篇文章主要讲解了关系操作符和逻辑操作符并附上了多个代码示例
温轻舟
47 1
五：《初学C语言》— 操作符

热门文章

最新文章

  • 1
    【C语言】深入浅出：C语言链表的全面解析
  • 2
    【C语言】输入/输出函数详解
  • 3
    【C语言】宏定义详解
  • 4
    C 语言中所有可用的关系运算符
  • 5
    【c语言】运算符汇总（万字解析）
  • 6
    【C语言】结构体详解 -《探索C语言的 “小宇宙” 》
  • 7
    【C语言】enum 关键字详解
  • 8
    C 语言中的数据类型转换：连接不同数据世界的桥梁
  • 9
    【C语言】原码、反码、补码详解 -《码上有道 ! 》
  • 10
    【C语言】深入解析C语言结构体：定义、声明与高级应用实践
  • 1
    C语言易混淆、简单算法、结构体题目练习、常见关键字总结-2
    63
  • 2
    C语言易混淆、简单算法、结构体题目练习、常见关键字总结-1
    66
  • 3
    操作系统实战（一）（linux+C语言）
    135
  • 4
    C语言学习
    50
  • 5
    C语言：深入补码计算原理
    89
  • 6
    C语言：预处理
    73
  • 7
    C语言：编译与链接
    61
  • 8
    C语言：文件操作
    55
  • 9
    C语言：动态内存管理
    63
  • 10
    C语言：自定义类型 - 结构体 & 联合体 & 枚举
    64

    • 相关课程

    更多
  • 你的第一门C语言课
  • C语言学习教程
  • Go语言核心编程 - 基础语法、数组、切片、Map

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 函数类型-3：函数重载
  • 函数类型-1：基本语法
  • 语言入门-2：基本类型
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月