第2章 基本数据类型与简单程序设计

运行环境以Dev-C++为主

0.补充：进制相关

  • 1.进制基本概念
    • 基数：进位计数制中所采用的数码（数制中用来表示“量”的符号）的个数。
      • 如十进制的基数为10，含0~9十个数字
    • 位权：进位制中每一固定位置对应的单位值。
      • 如十进制的个位位权为10^0(1) 、十位位权为10^1(10)、 百位位权为10^2(100)，以此类推
  • 2.进制分类
    • 十进制：生活中最常用的进制，满十进一，包含数字0~9（任意十进制数拆分开都是由这十个基数构成）
    • 八进制：以0开头，满八进一，包含数字0~7（任意八进制数拆分开都是由这八个基数构成）
    • 十六进制：以0x或0X开头，包含数字0~9、 字母 A~ F或a~f； A/a代表数字10，F/f代表数字15（任意十六进制数拆分开都是由这十六个基数构成）
      • 用字母代替10~15可避免歧义，如果不引入字母的话，如0X931087中的10是看作十还是一和零，容易产生歧义
  • 3.二/八/十六进制转十进制
    • 拆分十进制数
      • 从十进制数的拆分出发，对比得到其他进制转为十进制的方法。
      • 2354=2x10^3 + 3x10^2 + 5x10^1 + 4x10^0=2354 ---> 每一位的数与该位位权相乘后相加求和
    • 拆分二进制
      • 二进制数只有0和1两种数字组成
      • 二进制数每一位的位权为2^n
      • (1100)2 = 1x2^3 + 1x2^2 + 0x2^1 + 0x2^0 = 12
    • 转换方法
      • 对于形式化的进制表示可以从0开始，对数字的各个数位进行编号，即个位起往左依次为编号0，1，2，……；对称的，从小数点后的数位则是-1，-2，……
      • 十进制数110，其中百位上的1表示1个10^2， 即100，十位的1表示1个10^1， 即10，个位的0表示0个10^0，即0
      • 二进制数110，其中高位的1表示1个2^2， 即4，低位的1表示1个2^1， 即2，最低位的0表示0个2^0，即0
      • 十六进制数110，其中高位的1表示1个16^2， 即256，低位的1表示1个16^1， 即16，最低位的0表示0个16^0，即0
    • 总结
      • 在数制中，各位数字所表示值的大小不仅与该数字本身的大小有关，还与该数字所在的位置有关，这种关系称为数的位权
      • 十进制数的位权是以10为底的幂，二进制数的位权是以2为底的幂，十六进制数的位权是以16为底的幂。数位由高向低，以降幂的方式排列。无论是二进制、八进制还是十六进制，各位上的位权与该位上的数相乘，最后再相加得到的和就是它转为十进制的结果。
  • 4.十进制转为二/八/十六进制
    • 方法1（基础方法）：短除法，除到商为0截止；余数要倒序相连
      • 注意：十进制转为多少进制，除数就是多少（除二取余 除八取余 除十六取余）
      • 案例

    • 方法2（进阶方法）
      • 原理：二进制转十进制是由若干个2的整数次幂相加得到的，那反过来，十进制转为二进制可以拆分为若干个2的整数次幂的和。
      • 必备：2的0到10的幂次方
      • 案例
      // 计算十进制数345的二进制数
// 离345最近的是256 345-256=89
// 离89最近的64 89-64=25 
// 离25最近的16 25-16=9
// 离9最近的8 9-8=1
// 所以345 = 256+64+16+8+1 
// 1、2、4、8、16、32、64、128、256、512 、1024中用到的写1，未用到的写0
// 即1（1）、 2（0）、4（0）、8（1）、16（1）、32（0）、64（1）、128（0）、 256（1）、 512（0） 、1024（0）
// 然后从后往前把括号里的数据读出来：0010 1011 001 省去无用的0，即101011001
// ====================或者=========================
// 345 = 256+64+16+8+1 = 2^8 + 2^6 + 2^4 + 2^3 + 2^0
// = 1x2^8 + 0x2^7 + 1x2^6 + 0x2^5 + 1x2^4 + 1x2^3 + 0x2^2 + 0x2^1 + 1*2^0
// 上式中与2的整数次幂相乘的1或0就是代表整数次幂的位权上的1或0，将2^8到2^0左边的0或1从左往右
// 排列依然是 101011001

1.C语言的基本数据类型

  • 字符型：char 1B
    • unsigned char 范围 0~225
    • signed char 范围 -128~+127
  • short：短整型 2B
    • unsigned short 范围 0~65535
  • int/long：整型/长整型 4B
  • float：单精度浮点型 4B
  • double：双精度浮点型：8B
  • 补充
    • 2^1 = 2
    • 2^2 = 4
    • 2^3 = 8
    • 2^4 = 16
    • 2^5 = 32
    • 2^6 = 64
    • 2^7 = 128
    • 2^8 = 256
    • 2^9 = 512
    • 2^10 = 1024
    • 2^15 = 32768
    • 2^16 = 65536

2.常量和变量

  • 2.1 常量和符号常量
    • 程序运行过程中值保持不变的量为常量
    • 常量可以用一个标识符来表示，即符号常量
  • 2.2 整型常量（需要先掌握进制相关知识）
    • 数值举例
      • -1234 十进制整型常量
      • 01234 八进制整型常量
      • 0x1234 十六进制整型常量
      • 0L long型十进制整型常量（以L或l结尾）
    • 存储方式
      • 任何类型的数据在计算机中都是以二进制补码形式存储的，其中最高位为符号位（无符号型除外），1表示负数，0表示正数
      • 计算机中以二进制形式表示的数叫机器数，机器数通常带有符号（有正负数之分），计算机用最高位存放符号，这个bit一般叫做符号位。如十进制中的数+7，计算机字长按8位算，转换成二进制就是00000111；如果是-7，就是10000111
      • 源码：直接表示数值大小和符号的编码方式。在二进制数中，最高位作为符号位，其余位表示数值的大小。
      • 反码
        • 正数：等于源码
        • 负数：在源码的基础上，符号位不变，其余位取反
      • 补码
        • 正数：等于源码
        • 负数：在反码的基础上，最低位加1
  • 2.3 浮点型常量
    • 普通表示法：1234.56、-1.2、0.0、.5、6.、1000000000.0
    • 科学计数法
      • 合法案例：1.23456e2、 0.345E-3、-765e12、-.5E-8、6.e-7、1.0e10
      • 判断规则
        • 1.字母e（或E）之前必须有数（正数、负数、整数、小数均可）
        • 2.如果字母e（或E）之前是小数，小数点左边或右边应有数字
        • 3.在字母e（或E）之后必须是整数。
      • 非法案例：1.34E1.2、.e2
  • 2.4 字符型常量
    • 补充：编码
      • ASCII码
        • 主要用于表示英文字符，共8bit，即用8位来表示1个字符，总共可以表示2^8=256种英文字符。
        • 计算机由美国发明产生，在产生初期并没有预料到它会广泛应用于全世界，所以最初的编码方式只有ASCII码，用来表示英文足够了。例如A的ASCII码为“0100 0001”，低层硬盘存储的实际上是这8位01代码。
        • 随着计算机发展，各国都要使用计算机，但ASCII码无法表示所有国家的语言，这就导致了乱码的产生。
      • 万国码(Unicode码)
        • 主要用于表示所有国家的文字字符，共32bit，可表示2^32种字符，也可以表示中文。
        • 它拓展了ASCII码的表示范围，但浪费了硬盘的存储空间，如A的Unicode码为“00000000 00000000 00000000 0100 0011”。
      • UTF-8编码
        • 给Unicode码做压缩，位数为8的整数倍（8/16/32等），用尽量少的字符表示Unicode能表示的字符，如A的UTF-8码与ASCII码一致，均为“0100 0011”。
        • 假设某字符的Unicode码为“00000000 00000000 00000100 00111000”，则用UTF-8表示为“00000100 00111000”，可显著减少存储空间。
    • 定义：用单引号（英文状态 即撇号 ''）括起来的一个字符
    • 特征：字符数据存放在内存时，并不是字符本身，而是字符的代码，称之为ASCII码
    • 分类
      • 数字字符
        • 举例：'0' '1' '2' ... '9'
        • '0'的ASCII码为48，后续的数字字符依次递推
        • 将数字字符转为对应数字的计算方法：字符 - '0'，如'5' - '0' = 5
      • 英文字符
        • 举例：'a' 'b' 'c' ... 'z' 'A' 'B' 'C' ... 'Z'
        • 'a' 'z' 'A' 'Z'的ASCII码分别为97 122 65 90
        • 小写字母的ASCII码比大写字母的ASCII码大32
      • 转义字符
        • 举例：'\n' '\t' '\b' '\r' '\' ''' '"'
        • 上述转义字符看起来是两个字符，实际上只能算一个字符
        • 可以使用'\'加上一个1-3位的8进制数或'\x'（不是'\0x'）加上一个1~2位的16进制数表示的ASCII码值来表示转义字符。如'\101'，八进制的101转为十进制是65，所以它表示的字符为'A'
        • 补充1：关于'\b'（DevC++环境）
          • 在C语言中，\b不能消除\n， \b是退格符，它的作用是光标回退到上一个位置，而不是删除字符或换行（作用不完全等同于退格键BackSpace）。
          • 具体来说，\b的作用是使光标左移一位，如果后面紧跟其他字符，则会覆盖前面的字符。例如，printf("12345\b");会输出12345，而printf("12345\ba");会输出1234a 。这说明\b只是用来移动光标位置，而不是删除字符。
        printf("12345\b");
printf("12345\ba");
        • 补充2：关于'\r'（DevC++环境）
          • 回车（不换行），用'\r'后边的字符替代这一行最开始的相同数目的字符，例如printf("aabbcc\rddee");会输出ddeecc。
        printf("aabbcc\rddee");
        • 利用转义字符'\r'动态打印进度条【生产环境应用】
        #include <stdio.h>
#include <windows.h>
int main(){
	int i;
	for(i = 1; i <= 100; i++) {
		printf("%d%%\r", i);
		Sleep(200);  // 程序睡眠200毫秒
	} 
	return 0;
}
        • 在读取大文件时，可结合'\r'打印文件的读取进度（百分比）（Python代码）【生产环境应用】
        import os
import time
# 1.读取文件的大小(字节)
file_size = os.stat('./file/zhangsan.jpg').st_size

# 2.逐渐地读取文件
read_size = 0
with open('./file/zhangsan.jpg', mode='rb') as f1:
    while read_size < file_size:
        chunk = f1.read(1000) # 读取固定大小的内容，每次最多读取1000B
        read_size += len(chunk)
        val =  int(read_size / file_size * 100)
        print("%s%%\r" %val, end="")
        time.sleep(0.01) # 睡眠0.01秒
      • 其他字符
        • 举例：'+' '*' '/' '&' ......
  • 2.5 变量
    • 定义：在程序的运行过程中，值可以改变的量称为变量
    • 特征
      • 每个变量都有一个名字，称为变量名，且必须进行变量说明，指明变量的类型
        • 变量声明形式：类型标识符 变量名;
        • 变量名（标识符）命名规则：只能由字母、数字和下划线组成，且第一个字符必须为字母或下划线，不允许使用数字。
        • 变量命名规范：见名知义，如姓名可声明为name变量，成绩可声明为score变量，不推荐用诸如a、b、c、xm（xingming）、nl（nianling）等
      • 编译系统依据变量类型在内存中分配合适大小的存储空间
      • C语言严格区分大小写，a和A是两个不同的变量
      • 举例
        • 合法变量：__ aa INT abc word_0c12
        • 非法变量： a b(整体) 1a #abc xyz-1
      // 1. 定义整型变量和字符型变量
int i, j, k;
char c1, c2;
int k = 50;  // 变量定义的同时赋初值
int k;
k = 50;  // 先电仪变量，然后赋初值

// 2. 定义浮点型变量
float x1, x2;
double z1, z2;
float x;
double y;
x = 123456.789;  // float x = 123456.789; 
y = 1.23456789E5;
// C语言中float的有效位数是7，即精确到有效数字的第7位；double的有效位数是17

// 3.定义变量时的注意事项
double y = k = 12.3;  错误,该语句并未完成变量k的声明,自然无法对其赋值
double y, k;
y = k = 12.3;  正确,先声明变量,再进行赋值
double y = 12.3, k = 12.3; 正确,声明单个变量的同时接着赋值

3.赋值语句

  • 3.1 赋值语句的格式与功能
    • 赋值原理
      • 将一个数据存入一个连续的具有若干存储单元的存储空间中，该存储空间有一个名字，即变量名
      • 变量定义后如果没有进行赋值，它的值是不确定的，因此操作变量之前要进行赋值
    • 一般形式
      • 变量 = 表达式;
    • 执行逻辑
      • 首先计算赋值号“=”右边表达式的值，然后将结果值送给赋值号“=”左边的变量
    • 注意事项
      • 1.赋值号的写法和数学中的等号一致，但两者的意义完全不一致
      • 2.赋值语句看上去和数学中的等式一致，但它的执行逻辑是从右往左，跟数学表达式也不一样
      • 3.赋值语句最后方会有";"，而赋值表达式没有
      • 4.赋值号的左边必须是一个变量，不能是常量或表达式
    // 非法赋值语句
'A' = a + 1;
3 = x / 2;
a + b = 12;
    • 复合赋值运算符
      • += -= *= /=
    c += 32  // c = c + 32
i *= a + b  // i *= (a + b)  i = i * (a + b)
    • 案例分析
    // 1.简单赋值语句
g = 9.8;
g = 10 + 20 - 9;

// 2.定义两个字符型常量
char  c1, c2；
c1 = 'a';
c2 = 'b';
// 上面的程序语句定义了2个字符型变量 c1, c2，一个字符型变量可存放一个字符。
// 将一个字符常量存放到一个字符变量中，并不是把该字符本身放到内存中，而是将该字符的相应的ASCII码存放内存
// 单元中，所以C语言字符型数据与整型数据之间可以通用。

// 3.给变量赋值
# include <stdio.h>
int main() {
  char c1 = 'a', c2;
  int k;
  k =  c1;
  c2 = 97;
  printf("%c,%c,%d\n", c1, c2, c1);
  printf("%d,%c\n", k, k);
  return 0;
}

// 4.将小写字母转换成大写字母
#include <stdio.h>
int main() {
  char c1, c2;
  c1 = 'a';
  c2 = c1 - 32;
  printf("%c,%c", c1, c2);
  return 0;
}
  • 3.2 赋值语句中的类型转换
    • 原因与转换逻辑
      • 赋值语句（或赋值运算表达式）中“=”左边的变量与右边表达式的数据类型不一致
      • C编译系统会自动实现数据类型的转换，将赋值号右边的表达式值的类型转换成与左边变量相同的类型后再赋值。
        • 注意1：当左边变量的数据类型比右边表达式值的类型长（如int型转为float型或double型），转换后的值不改变精度或准确度，只改变值的表示形式
        • 注意2：当右边表达式值的类型比左边变量的类型要长时，转换结果会对右边的数据进行截取，仅取出与左边变量类型相同的长度，这意味着会丢失高位数据，可能导致精度降低或出现错误
      #include <stdio.h>
  int main() {
    double x;
    int a = 350;  // 二进制为 1 0101 1110
    char c;
    c = a;  // 变量c只取变量a的低8bit
    x = a;
    printf("a=%d, c=%d, x=%f\n", a, c, x);
    return 0;
  }
// a=350, c=94, x=350.000000

4.数据的输出

  • 4.1 字符输出函数putchar()

    • 主要功能：把一字节的代码值所代表的字符输出到显示器上
    • 一般形式：putchar(c)
    • 注意事项
      • 1.参数c可以是字符常量、变量或字符表达式
      • 2.将参数c的值作为ASCII码值，把该值对应的字符输出到显示器上
      • 3.函数原型为“int putchar(int character);”
    • 案例分析
    putchar(65);  # A
putchar('0' + '1');  # a

  • 4.2 格式化输出函数printf()

    • 主要功能
      • 按指定的格式完成输出过程，向显示器输出信息
    • 一般形式
      • printf("输出格式串", 表达式表);
    格式符 功能说明
    %c 按字符形式输出
    %d 按十进制形式输出
    %o 按八进制形式输出
    %x 按十六进制形式输出
    %f（%e） 按浮点形式输出，默认为6位小数（科学计数法）
    %m.nf 按浮点形式输出，显示宽度不小于m，n位小数。
    • 执行逻辑
      • 格式符：将对应的表达式的值按指定格式输出到显示器
      • 非格式符：原样输出
    • 注意事项
      • 1.输出格式串中格式符个数与表达式个数一致
      • 2.输出格式符以"%"开头，若想打印出"%"，可通过"%%"打印
      • 3.若以%m.nf的形式输出，当数据的位数高于m时原样输出；当数据的位数低于m时加空格
      • 4."%"和"f"中间的数若是负数，则表示输出时左对齐，否则输出时右对齐，"%d"类似
    • 案例分析
    // 1.格式符的作用
#include  <stdio.h>
int main() {
  float  x1 = 123.5678,  x2 = -4567.789;
  printf("x1 = %f, x2 = %f \n", x1, x2 );
  printf("x1 = %8.2f \t x2 = %-8.2f \n", x1, x2 );
  // 算上小数点共8位 小数点后2位 为右对齐
  // 算上小数点共8位 小数点后2位 为左对齐
  printf("%c%3c \n", '*', '*' );
  printf("%d%3d \n", 11, 22 );
  return 0;
}
// 2.整数输出
#include <stdio.h>
int main() {
  int a=1234,b=01234,c=0x1234;
  printf("a=%d, b=%o, c=%x\n",a,b,c);
  printf("a=0%o, b=%d, c=%d\n",a,b,c); 
  return 0;    
}
// 3.浮点数输出
#include <stdio.h>
int main(){
  float x;
  double y;
  x = 1.23456789;      
  y = 1234.56E7;
  printf("%f,   %.1f,   %e\n", x,x,x);
  printf("%10.0f, %20e, %20.3e\n", y,y,y);
  return 0;
}

5.数据的输入

  • 5.1 字符输入函数getchar()

    • 主要功能：接收从键盘上输入的字符。在程序中使用这个函数输入字符时，可以用另一个变量接收读取的字符
    • 一般形式：c = getchar();
    • 注意事项
      • 1.执行上述语句后，程序等待用户输入，当用户按下某个键时，变量c就得到了该键的代码值
      • 2.该函数不接收参数，但有返回值
      • 3.用户在按下键盘时，可输入整数
    • 案例分析
    #include <stdio.h>
int main() {
  char  ch; 
  ch = getchar(); 
  printf("ch = %c, ch = %d \n", ch, ch);
  return 0;
}

  • 5.2 格式化输入函数scanf()

    • 主要功能
      • 按指定的格式从键盘接收输入信息
    • 一般形式
      • scanf("格式串"，地址表);
    格式符 功能说明
    %c 接收（输入）一个字符型数据 从键盘接收
    %d 接收一个整型数据，直到遇到空格//回车
    %f 接收一个浮点型数据（float）
    %lf 接收一个浮点型数据（double）
    • 执行逻辑
      • 将从键盘上接收的数据存入对应地址的存储空间中
      • 格式符：按指定格式输入数据
      • 非格式符：按原样输入
    • 注意事项
      • 1.格式串中格式符个数与地址表中地址的个数一致
      • 2.若有多个输入项，各项信息之间可以用空格、tab键或者回车键作为分隔符
        • scanf("%d%d"， &x, &y); 可以以空格 tab 回车作为间隔输入数据
        • scanf("%d %d"， &x, &y); 可以以空格 tab 回车作为间隔输入数据
        • scanf("%d,%d"，&x, &y); 只能以“,”作为输入数据的分隔符
    • 补充：地址
      • 无论是在内存还是在硬盘中，存取数据都需要找到对应地址，它是一个十六进制的串
      // 以下代码打印了变量k的值，随后打印了变量k的地址。内存中首地址为62fe1c的地址块存储了变量k的值
#include <stdio.h>
int main(){
  int k = 5;
  printf("%d\n", k); // 5
  printf("%x\n", &k); // 62fe1c
  return 0;
 }
      • 变量名在编译后会消失，变为一个十六进制数的内存地址
      • 机器代码中不会出现变量名，变量名用来给用户操作内存使用
    • 编程步骤分析：当我们拿到一个题目，如何编写程序完成呢？大概分为4个步骤
      • 1.需求分析，定义变量。程序运行的过程需要用变量存储数据，比如要计算一个数的平方根，可定义2个变量，一个用于存储原数，一个用于存储计算得到的平方根
      • 2.数据输入。通常会用到函数scanf()。题目一般不会直接给定确认的数字，而是要求输入一个或多个的数据，此时根据函数scanf()的语法编写语句即可
      • 3.数据处理。根据步骤二输入的数据建立数学模型，用程序代码、语句实现需求。如计算圆的面积，用S=πR^2;计算实数的绝对值，我们要想到fabs()函数等等。求得的值通常需要变量来接收
      • 4.数据输出。实现了需求，要确定代码能否真正能够满足题目要求，所求的值是否正确，所以要用到printf()打印输出，此时根据函数printf()的语法编写语句即可
    • 案例分析
      // 1.计算圆的面积和周长
#include  <stdio.h>
#define  PI  3.1415926
int main(){	
  float d, area, len, r;
  printf("请输入直径的值：");
  scanf("%f", &d);
  r = d / 2;
  area = PI * r * r;
  len =2 * PI * r;
  printf("半径r=%f, 面积S=%f, 周长L=%f\n", r, area, len );
}
// 2.逻辑错误代码
#include <stdio.h>
int main() {
  double a, b, c;
  printf("请输入两个double类型的数据:\n");
  scanf("%f,%f", &a, &b);
  c = a + b;
  printf("它们的和是:\n");
  printf("%f", c);
  return 0;
}

6.运算符和表达式

  • 6.1 算术运算符

    • 分类
    运算符 运算 优先级 例子
    () 圆括号 1 5/(1-3)=-2
    * 乘法 3 7*3=21
    / 除法 3 7/3.0=2.333333,7/3=2
    % 模除 3 7%3=1 5%(1-3)=1
    + 加法 4 7+3=10
    - 减法 4 7-3=4
    • 注意事项
      • 1.模除运算是两个整数相除后取余数，要求 “%” 两边必须是整型数据
      • 2.若算术运算符两边均为整数，则结果仍为整数，不同于数学中的运算
      • 3.若参加运算的两个数中有一个数为实数，则结果为double型
      • 4.每个运算符都有一个优先级，混合运算式中要考虑到优先级，括号可改变运算次序
        • 按运算符的优先级高低次序进行。如先乘除，后加减
        • 若一个运算符对象两侧的运算符的优先级相同，则按规定的“结合方向”（左结合或右结合）处理
    • 案例分析
    #include <stdio.h>
int main() {
  printf("%d\n", 5/(1-3)); // -2
  printf("%d,%f\n",7/3, 7.0/3);  // 2,2.333333
  printf("%d\n", 5%(1-3)); // 1
  return 0;
}

  • 6.2 自增、自减运算符

    • ++为自增运算符、--为自减运算符，“右结合性”，优先级为2
    • 一般格式
      • k ++; 等价于 k = k + 1;
      • k --; 等价于 k = k - 1;
    • 特殊形式：运算次序不同
      • i = k++; 等价于 i = k; k = k + 1;即先将k最初的值复制给i，再执行k = k +1;
      • j = ++k; 等价于 k = k + 1; j = k;即先将k的值加1，新值复制给j;
    • 注意事项
      • 1.++和--运算符多用于int型和char型，float、double也可以用但用的不多
      • 2.避免写 a = b+++--c 类似的语句，有歧义
      • 3.++和--运算符不能用于常量，如++5非法
    • 案例分析
    #include  <stdio.h>
int main() {
  int  i, j, k;
  k = 30;
  i = k++;  // 先将k值30赋给i, 再使k值增1, 此时k =31, i = 30   
  printf("i = %d, k = %d", i, k );
  j = ++k;  // k值先增1, 再将k值赋给j, 此时k =32, j = 32      
  printf("\n j = %d, k = %d", j, k );
}

  • 6.3 赋值运算符

    • “=”，“右结合性”，优先级为14。执行逻辑等知识可参考前面第3部分“赋值语句”
    • 案例分析
    #include <stdio.h>
int main() {	
  double  k, x, y;
  // 先将9.8赋给k，“(k = 9.8)”表达式值为9.8，然后再加7得16.8
  x = (k = 9.8) +7;
  printf("k=%5.1f,\tx=%5.1f\n", k, x );
  // 运算符"+"的优先级高于"="，且"="是右结合，先算9.8 + 7，值为16.8赋给k，再将k的值16.8赋给y
  y = k = 9.8 + 7;
  printf("k=%5.1f,\ty=%5.1f\n", k, y );
}
// k=  9.8,    x= 16.8
// k= 16.8,    y= 16.8

  • 6.4 逗号运算符

    • 用于将两个表达式连接起来，优先级为15，最低
    • 一般形式：表达式1, 表达式2, ..., 表达式n
    • 执行逻辑：先求解表达式1，再求解表达式2，依次求解直到表达式n。整个逗号表达式的值为表达式n的值。
    • 案例分析
    // 1.表达式n的值不受前方表达式的影响
x = (i=1, j=2, k=3)

// 2.表达式n的值受前方表达式的影响
a=3, b=5, --a

  • 6.5 位运算

    • 定义：对操作数以二进制位 (bit) 为单位进行的数据处理，运算的运算对象是一个二进制数位的集合
    • 分类与运算特征
    运算符 含义 优先级 格式 备注
    ~ 取反 2 ~ a 0变1，1变0
    << 左移n位 5 a << n 新值在原值的基础上*2^n
    >> 右移n位 5 b >> n 新值在原值的基础上/2^n
    & 按位与 8 a & b 当两个对应位均为1时，结果为1，否则为0
    ^ 按位异或 9 a ^ b 当两个对应位相同时，结果为1，否则为0
    竖线 按位或 10 a 或 b 当两个对应位均为0时，结果为0，否则为1
    • 案例分析
    // 1.根据位运算符的特征计算以下算式的结果
// 要点：1.将十进制数转为二进制数 2.根据优先级确定运算顺序,根据位运算符的运算规则求得结果 3.将二进制结果转为十进制数
unsigned char a=2, b=4, c=5, d=16, e=7, y;
y = a&b;
y = a|b;
y = a^c;
y = a<<2;
y = d>>2;
y = ~e;
y = d&e<<2

  • 6.6 强制类型转换

    • 运算符为(类型),优先级为2
    • 一般形式：(类型)表达式
    • 执行逻辑：将表达式的结果类型强制转换成指定类型
    • 注意事项
      • 1.浮点型强制转换为整型时，不是进行四舍五入，只是进行取整。
      • 2.当强制类型转换符和其他运算符一起出现时，注意优先级和运算顺序
    • 案例分析
    // 下式中强制类型转换的优先级2高于除号3，所以先将(float)1转为1.0，然后再计算1.0/2=0.5
(float)1/2

7.常用的数学函数

8.顺序结构程序设计实例

posted @   pycoder_666  阅读(82)  评论(0)  编辑  收藏  举报
相关博文：
·  2022级6.7.天师班C语言寒假作业
·  第1章 C语言概述
·  2 C 语言学习-数据类型
·  C语言基础知识梳理
·  C语言与设计（专升本）
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· 写一个简单的SQL生成工具
· AI 智能体引爆开源社区「GitHub 热点速览」
点击右上角即可分享
微信分享提示