C语言笔记

C语言

1 C语言基础知识

1.1 进位计数制

1.1.1 下标：

​ 二进制()~2~ B 八进制()~8~ O/Q
​ 十进制()~10~ D 十六进制()~16~ H

1.1.2 进制转换

​ 方法：整数：转几除几，倒取余
​ 小数：转几乘几，正取余

1.2 字符在计算机内部的表示

• 字符在计算机内部以ASCII码存储，占1个字节，**整形数据在计算机内以补码**表示。

  大写字母：A-65，……Z-90

  小写字母：a-97，……z-122

  数字字符：0-48,1-49.……9-57

  空格：32 **\0’**的ASCII码是 0

• 大小写转换要±32

2 C语言的概述

2.1 C语言的基本概念

1. C语言编写的程序成为**源程序（.c），不可直接执行，先经过编译变成目标程序（.obj），在经过链接**处理后才可运行，处理后生成的文件扩展名是（.exe）

graph LR
C语言-->|编写|D[源程序.c]-->|编译|E[目标程序.obj]-->|链接|F[文件.exe]

2. 由高级语言编写的程序称为**源程序**

2.2 程序化设计

1. C语言是一种结构化的程序设计语言，它提供了三种**基本结构语句，结构化程序通常由三种基本结构组成，包括顺序，选择，循环**。

2. C程序由**函数组成，函数是组成C程序的基本**单位，语句是C程序的最小单位。

3. C程序总是从**主函数开始执行，由主函数结束，主函数**的位置是任意的

4. 语句最后以**分号**结束

5. 一行可以写**一条或多条语句，一条语句也可以写一行或多行**

6. 标识符

   1. 组成：数字，字母，下划线，开头只能是**字母或下划线**

   2. 标识符分为关键字，预定义标识符，用户标识符。

      关键字都是小写字母，不能用做用户标识符，预定义标识符包括（define，include，scanf，printf）可以作为用户标识符但不建议。

      标识符区分大小写

3 数据类型极其运算

3.1 数据类型

1. 常见的基本数据类型包括**整型，实型，字符型**。

   1. 整形包括**常量，变量**

      • 常量：在程序运行中，值不可改变的量
      • 变量：在程序运行中，值可以改变的量

3.1.1 整形常量

1. C语言中没有二进制

2. 八进制前导**$\large 0$**

3. 十六进制前导**$\large 0x$或者$\large 0X$**

4. %d 十进制
   %o 八进制
   %x：十六进制数（字母小写）^1
   %X：十六进制数（字母大写）^1

   • 输入有前导，==输出无前导==

3.1.2 整型变量

数据类型	型号	字节数
int	基本型	TC系统占2个字节
		vc系统占4个字节
short	短整形	占2字节
long	长整形	占4字节
unsigned	无符号型

• 未赋值的变量输出时默认为随机值

• 当格式字符少于输出项时多余的输出项不输出

  printf（“%d”,a,c）不输出c

• 当格式字符多于输出项时输出随机值

  printf（“%d，%d”,a）输出一个a一个随机值

3.1.3 实型常量

1. 小数点式

   1. 小数点式：由**数字，正负号，小数点**组成
      • 小数点式：必须有小数点，至少一边有数字
        • $0.78\Rightarrow.78$ $3.0\Rightarrow 3.$

   指数形式

   1. 由E或者e组成

      • $12.34E+2\Rightarrow12.34\times10^{+2}$

      • $12.34e-2\Rightarrow12.34\times10^{-2}$

      • E或e的**两边必须有数字，右边（指数部分）必须是整数**

        $3.14E-7.0(X)$ 右边的7.0是实型中的小数点式

   实型变量

   • 单精度：float 占4字节
   • 双精度：double 占8字节
   • %f：十进制浮点数
     • %f输出默认保留**==6位小数，不足补0，超过6位四舍五入==**
     • 当多个类型的值进行混合运算时，运算结果为字节数**最大的类型*

3.1.4 字符常型

• 常规字符常量

  • 单引号只能放一个字符，一个字符一个字节

  • 转义字符

    ‘\n’:换行

    ‘\t’:横向跳格（跳过8列）

    ‘\b’:左移覆盖 printf（“abcd\b1234”）;=printf(“abcd\b”)

    ‘\’‘’:输出’

    ‘\"’:输出”

    ‘\\’:输出\

  • 八进制转义字符：‘\ddd’一到三位八进制表示一个字符

    • ‘\101’ ‘\006’ ==前导的0可加可不加==

  • 十六进制转义字符：‘\xhh’一到二位十六进制表示一个字符

    • ‘\xab’ ==前导x必须有==

• 字符串常量

  • 双引号括起多个字符 例如“ABCD”占**5**个字节
    • 字符串后面还有个**‘\0’，其为字符串的结束标志**

3.1.5 字符型变量

• char 占一个字节

  %c 只能输出一个字符

• printf（“%c\n”,‘A’） ； A
  printf（“%d\n”,‘A’） ； 65

  • ==如果以%d形式输出一个字符，则输出他的ASCII码值。==

3.2 常见运算符

3.2.1 算数运算符

• 算数运算符：+，-，*，/，%

  • $/$两边都是整形的话，结果就是一个整形，任意一个为实型，结果为实型。

    • 4+3.0=7.0

  • $%$两边要求是整数，余数正负号与被除数（左边的数）一致。

    • -7%3=-1

    • 并且**求余运算符的对象必须是整型**

    • 整型变量只接受整数部分

      int a=1;
            
         float b=2.5;
            
          a=b;
            
          a=2;

3.2.2 强制类型转换符

• 形式：(类型名)表达式

  （int）x/2 解释运算过程：将X强制转换成整形，最后结果除以2

  （int）（x/2） 解释运算过程：将（x/2）的结果强制转换成整形

  • 强制转化只对结果有影响，表达式还是原来的类型并未改变

    • 按照指定宽度输出

  • 指定>宽度 ==左补==空格

  • 指定<实际 原样输出

    int a=1234;
    printf("a=%5d\n",a);	a=_1234
    printf("a=%2d\n",a);	a=1234

• %m,nf

• m-代表数据总长（包含小数点），n代表小数位数

  实际>n 四舍五入

  实际<n 补零

  float f=3.1415；
  printf("f=%7.2f\n",f);	f=_ _ _3.14
  printf("f=%10.5f\n",f);	f=_ _ _3.14150
  printf("f=%4.3f\n",f);	f=3.142	//实际五位数，大于要求的四位数，原样输出

• int的数据范围是-32768~+32767

• int a=1；

  for（;a>0;a++）是死循环

• 无符号数据范围0~65535

  • 无符号65535与int型-1对应

• %u：无符号十进制整数

数据输入

1. 整型数据输入如果没有其他符号分隔，用空格或回车分隔

   scanf（“%d%d”，&a&b）; 1_2 或者 1回车2

2. 指定输入数据的宽度时输入宽度不得少于指定宽度

3. 实型数据输入时，不能指定小数位数

   scanf（“%3.2f”，&f）；（X）

4. %c前不能加空格，因为空格也是字符，也会被输入进去

5. 字符输入函数：getchar（）

   字符输出函数：putchar（）

   只针对一个字符的输入和输出

   char ch;
   ch=getchar();
   putchar(ch);

• ==将两个整数a和b的值互换后输出==
  • t=a,a=b,b=t; 空瓶子原理（需要定义第三变量）
  • a=a+b；b+a-b；a=a_b; 和差差（不需要定义第三变量）

4 选择结构

4.1 关系运算与逻辑运算

• C语言中：C语言将非零值视作真。0值视作假

4.1.1 关系运算

• $>>,>=,<,<=,==,!=$
  • 成立 ：1 不成立：0

4.1.2 逻辑运算

• 逻辑运算符：！，&&，||

  • &&：有0为0，全1为1
    • 条件同时满足
  • ||：有1为1，全0为0
    • 只满足一个就可以
  • ！：取反
    • 1+2&&3+4结果为1
  • 符号优先级

  优先级	运算符
  1	！
  2	算数运算符 *,/,%大于+,-
  3	关系运算符 <,>,>=,<=大于==,!=
  4	&&
  5	||
  6	赋值运算符
  7	逗号运算符

  • 逻辑与运算与逻辑或运算同时出现时，&&运算优先级高，先结合

    从左向右计算

    • ++a||++b&&++c=++a||(++b&&++c)

4.2 条件运算符号（三目运算符）

• 形式：条件1？值1；值2

  • 条件为真，结果为值1；为假：则结果为值2

    #include <stdio.h>
    int main() {
        int a=2,b=1,c=3,d=4; 
        int result=(a<b?a;c<d?a;d);
        printf("结果是：%d\n",result);	//结果是：2
        return 0
    }

4.3 if语句

• 单分支if(语句)

  • 条件为真，执行语句，为假，则不执行
  • if只能控制一条语句，==if语句后的分号比较重要==

• 双分支if(语句)

  • 真，执行if语句，假，执行else
  • 出现多个else时，要注意配对原则
    • 就近原则，else总是和**==上面的，最近的，未配对==**的配对

4.4 switch语句

• 看括号里的内容，执行与case对应的，顺序执行，直到break跳出循环
  • 先进入，后向下
  • case后面必须是**整形常量或常量表达式**（switch括号内一样）
  • default表示“其他”分支，可有可无，位置任意
  • break跳出循环

#include <stdio.h>

int main() {
    int num;

    printf("请输入一个数字（1-3）：");
    scanf("%d", &num);

    switch (num) {
        case 1:
            printf("你输入了数字1\n");
            break;
        case 2:
            printf("你输入了数字2\n");
            break;
        case 3:
            printf("你输入了数字3\n");
            break;
        default:
            printf("你输入的数字不在范围内\n");
            break;
    }

    return 0;
}

5 循环结构

5.1 while循环

• 形式：while（条件）语句；

  • 先判断条件，为真时循环，直到条件为假跳出循环

  • 循环三要素：初值，条件，增量

  • ==循环次数看成立几次==

  • 与if语句相同，while循环只控制一条语句

  • 常见用法-倒序输出

    #include <stdio.h>
    
    int main() {
        int x = 1234;
    
        printf("倒过来输出的数字是：");
    
        while (x > 0) {
            int digit = x % 10; // 取最后一位数字
            printf("%d", digit); // 输出最后一位数字
            number /= 10; // 去掉最后一位数字
        }
    
        printf("\n");
    
        return 0;
    }

5.2 do-while循环

• 形式：

  do语句;

  while（条件）;

• 先执行语句再判断条件，为真时循环，直到条件为假跳出循环

  • while后面分号不可以省略，代表循环语句结束
  • 循环次数也是看条件成立几次
  • 循环体执行次数比条件成立次数多一
  • do-while语句至少执行一次

5.3 for循环

• 形式：

  for（初值；条件；增量）语句；条件为真，执行语句，然后返回增量

  • 省略式1，执行式2
  • 省略式2，默认条件为真
  • 省略式3，回式2
  • 式子都可以省，分号不能省

• 循环次数看条件成立几次

5.4 break和continue

• break语句

  • 跳出循环，在那个循环内部，就跳出那个循环

• continue

  • 结束本次循环，进入下一次循环

    • while循环，回条件
    • do-while循环，回条件
    • forxunhuan,回增量

  • continue只跟循环语句有关系，看见continue就找循环

5.5 循环的嵌套

• 嵌套循环的次数为 内循环次数X外循环次数

• 常用嵌套代码-更相减损法

  #include <stdio.h>
  
  int main() {
      int a, b;
  
      printf("请输入两个整数：");
      scanf("%d %d", &a, &b);
  
      // 保证a和b是非负数
      if (a < 0) a = -a;
      if (b < 0) b = -b;
  
      // 使用更相减损法求最大公约数
      while (a != b) {
          if (a > b) {
              a = a - b;
          } else {
              b = b - a;
          }
      }
  
      printf("最大公约数是：%d\n", a);
  
      return 0;
  }

• 常用嵌套代码-辗转相除法

  #include <stdio.h>
  
  int main() {
      int a, b;
  
      printf("请输入两个整数：");
      scanf("%d %d", &a, &b);
  
      // 保证a和b是非负数
      if (a < 0) a = -a;
      if (b < 0) b = -b;
  
      while (b != 0) {					//除数
          int temp = a % b;				//余数=大%小
          a = b ;							//大=小
          b = temp;						//小=余
      }
  
      printf("最大公约数是：%d\n", a);		//输出被除数
  
      return 0;
  }

6 函数

6.1 函数的定义

1. 函数是组成c程序的基本单位，语句是最小单位
2. C程序总是从**主函数开始执行，由主函数结束，主函数**的位置是任意的
3. ==实参的类型可以与形参类型不一致，以形参的类型为准==
4. 实参和形参各占独立存储单元
5. 形参需单独定义，属于定时变量，调用函数时为其分配存储单元，调用结束后释放存储单元
6. ==函数应先定义后调用==
7. ==函数可以嵌套调用，但不可以嵌套定义==
   • $/large (int x,int y)（✓）(int x,y)（X）$
8. 函数默认为int型
9. ==函数返回值的类型是由定义函数时所指定的函数类型决定的==
10. main（）函数不能调用自己，其他函数都可以调用自己
11. return语句只能带回一个返回值，void表示函数无返回值
    • void可以定义函数，也可以定义变量
    • 函数不一定都有参数
12. ==函数的实参传递分为值传递和地址传递==

6.2 函数声明

• 形式：float fun（float x,float y）；
  1. 先定义，后调用
  2. ==先声明，再调用，最后定义==

（错题本上有道题可以放这里，这里先按下不表）

6.3 函数的调用

• 函数调用形式
  1. 语句调用 fun（a,b）;
  2. 表达式调用 y=fun（a,b）;
  3. 嵌套调用 将函数的返回值作为实参进行调用
     • fun(a,fun(a,b))
  4. 递归调用 函数直接或间接的调用自己
     1. 直接递归 A->A
     2. 间接递归 A->B->A

7 数组

7.1 定义

​ 类型说明符 数组名【常量表达式】；

• int a [ ]；

• 中括号是**整型常量或整型常量表达式**。

• 定义数组时，需要指定数组元素个数，方括号中的整形常量或整型表达式用来表示元素的个数，即数组长度。

• 中括号中的常量可以是符号常量（宏定义中的字符）。

  • #define N 10

    int a [N]；

• 不可以给整型数组赋字符串 char s【】;s=“right!”; [x]

7.2 一维数组的应用

• 数组必须先定义，再使用
• 引用形式：数组名【下标】 、
  • 数组的下标都是**从0开始**的
• 数组初始化可以少赋值，不能多赋值
• 未赋值的部分默认为0
• 数组长度为初始化元素个数

7.3 二维数组的应用

• 引用形式：数组名【下标】【下标】
• ==行下标可以省略，列下标不能省略==
• 没赋值，则行列都不可省
• 初始化至少赋一个值

8 指针

• 指针的概念

  • ==指针就是地址==

    变量的指针就是变量的地址

• 指针的定义

  • 基类型*指针变量名 int * p；
  • $$ **==只有在定义语句中是指针定义符==***

8.1 指针的赋值

• 通过取地址运算符：&

  • int a , * p

    p = & a ;

• 通过另一个指针

  • int a，* p ， * q；

    p = & a ; q = p ;

• 空指针的定义

  • int * p = NULL ;
  • 其值为0

• 指针的操作

  • &：取地址运算符
    • p = & a
  • *：取内容运算符
    • * p = a

8.2 指针与一维数组

1. 一维数组的地址

   • a是数组名，即一维数组的首地址，第0个元素的地址，即&a[0]

2. 一维数组常用表达式

   • a ：& a [0]
   • a+i : & a [i]
   • * (a+i): a [i]

3. 指向一维数组的指针

   • 指针指向哪一位，哪一位就是该指针的首元素

   • *++p：指针后移，取值

   • ++*p：先取值，加一

   • *p++：先取值，指针后移

   • ==数组名是地址常量，不可赋值。指针是变量，可以赋值。==

   • 指针比较大小就是比所在位置的大小

   • 指针可以想减不能相加

4. 函数之间对一维数组的引用

   实参	形参	传递方式
   数组元素 a [1] a [2]	变量	值传递
   数组元素地址 & a [1]	指针	地址传递
   数组名 a	指针	地址传递

8.3 指针与二维数组

• 前面为行，后面为列
• ==二维数组引用时出现，[]任意两个代表内容，出现一个代表地址==*

8.4 数组指针与指针数组

8.4.1 数组指针

• int ( * p ) [4];
  • p为类型的int型数组的指针。数组长度为4
  • 一个指向M个整形元素的一维数组指针

8.4.2 指针数组

• Int * q [3]；

  • q是由三个指针变量构成的数组，简称指针数组。q[0]，q[1]，q[2]，均为int *

    每一个元素都是一个指针，每个元素都是地址

    数组	数组名	元素
    int q [3]	整形元素	数值
    Int * q [3]	整型指针元素	指针

8.5 函数指针和指针函数

8.5.1 函数指针

• int ( * p )();
  • 说明p是返回值为整形函数的指针

8.5.2 指针函数

• int *p()；

  • 说明函数值为整型指针的函数

• ==p先和*结合说明是指针，p先和【】结合，说明是数组，p先和（）结合，说明是函数。==

9 字符串

9.1 字符数组与字符串

1. 字符数组定义

   用来存放字符的数组就是字符数组。

2. 字符数组的初始化

   省略的元素默认为‘\0’

   长度默认为初始化元素个数

3. 字符数组与字符串

   字符数组中，存放‘\0’，就当做字符串

9.2 字符串指针

1. 定义

   char *p；

2. 字符串指针赋值

   char *p=“ABCD”;或者 char s[5]={“ABCD”}

   字符串给指针赋值，指针只接收字符串首地址

9.3 字符串的输入与输出

1. 利用scanf和printf

   字符串输出时遇到‘\0’结束

   %s:输出一个字符串

   %c:输出一个字符

2. 字符串输入输出函数

   输入：gets（）^2

   输出：puts（）^2

   专门用于字符串的输入输出

   ==带空格的字符串不能用scanf输入，必须用gets（）==

9.4 字符串函数

9.4.1 字符串长度函数 strlen

==strlen（）不包括‘\0’，sizeof（）包括\0’，当参数是数组名时，直接输出数组的长度。==

9.4.2 字符串复制函数 strcpy

strcpy（字符数组1，字符串2）

将字符串2复制到字符数组1中，类似替换

==字符数组1的长度不能小于字符串2的长度==

9.4.3 字符串连接函数 strcat

strcat（字符数组1，字符数组2）

把字符数组2接到字符数组1之后（只有字符串1变化）

字符数组1必须足够大，以便容纳链接后的新字符串，链接后字符串1后面的‘\0’取消，只保留新串最后的\0’

#include <stdio.h>
#include <string.h>

int main() {
    // 声明并初始化两个字符串
    char str1[50] = "Hello, ";
    char str2[] = "World!";
    
    // 输出原始字符串
    printf("Before strcat:\n");
    printf("str1: %s\n", str1);
    printf("str2: %s\n", str2);
    
    // 使用strcat连接str2到str1
    strcat(str1+1, str2+1);
    
    // 输出连接后的字符串
    printf("\nAfter strcat:\n");
    printf("str1: %s\n", str1);
    
    return 0;
}

运行结果

Before strcat:
str1: Hello, 
str2: World!

After strcat:
str1: ello, orld!

9.4.4 字符串比较函数 strcmp

• 比较字符串1和字符串2（用ASCII比较）
  • 串1大 1
  • 一样大 0
  • 串2大 -1
• 只能通过字符串比较函数比较字符串大小，不能通过关系运算符比较

10 变量作用域与存储类

10.1 作用域

10.1.1 局部变量

• 再复合语句内部或函数内部定义的变量称为局部变量
  • 自定义位置起，到符合语句或函数的结束

10.1.2 全局变量

• 自函数外部定义的变量称为全局变量
  • 自定义位置起，到程序结束
  • 局部变量和全局变量同时存在，先用局部变量

10.2 变量的存储类

1. 自动型：auto

   函数中的局部变量，默认都是自动型,在调用该函数时系统会给这些变量分配存储空间，函数调用结束时就会自动释放存储空间

   这类局部变量称为自动变量，用关键字auto做存储类别声明

auto	int	a
存储类	类型名	变量名

• 变量默认的存储类为auto类型

2. 静态型：static 内部变量,内部函数

   调用结束后不消失而累计，即其占用的存储单元不释放

3. 寄存器型：register

4. extern 外部变量，外部函数

10.3 动态存储方式与静态存储方式

• 静态区

  • 变量类型：静态局部变量，全局变量或外部变量
  • 生存期：整个程序
  • 初始化在编译阶段,初值为0

• 动态区

  • 变量类型：动态变量
  • 生存期：他所在的局部
  • 初值为随机值

• 变量

  • 局部变量
    • 动态
    • 静态
  • 全局变量
    • 静态

	局部变量	动态
变量		静态
	全局变量	静态

• int x; 其中的$X$是动态变量，初值为随机
• static int x；其中的$X$是静态变量，初值为0

11 编译预处理

C语言提供的预处理功能主要有三种：==宏定义，文件包含和条件编译==

11.1 宏定义

• 形式：
  • #define 宏名 替换文本
    • #defube B 5
  • #define 宏名（参数） 替换文本
    • #define f(x) x*x
• 预处理命令不是C语句，不用加分号
• 宏名习惯用大写字母，但是也可以用小写

11.2 文件包含

• 形式：

  • #include<文件名> 系统目录

  • #include“文件名” 系统目录+用户目录

    • stdio.h 标准输入输出头文件

      • 标准库函数

    • string.h 字符串函数头文件

      • strcmp

        strlen

    • math.h 数学函数头文件

      • sqrt

        fabs

• 提问方式

  • 只问头文件
    • stdio.h
    • string.h
    • math.h
  • 文件包含的整体格式
    • #include<stdio.h>
    • #include<string.h>
    • #include<math.h>
  • 问是什么命令
    • 文件包含/#include

• 例题

#include <stdio.h>
#define MAX( a , b ) ( a ) > ( b ) ? ( a ) ; ( b )
main() {
    int x , y , z ;
    x = 10 ;
    y = 15 ;
    z = 10 * MAX( x , y );		//先不要计算，先把宏定义替换带入进去
    //z=10*( x ) > ( y ) ? ( x ) ; ( y )
    printf("%d\n",z);			//结果为10
}

11.3 条件编译

不在考纲内，不想学了

12 结构体

在C语言中，数组是表示类型相同的数据，而结构体则是若干类型不同数据项的集合；

12.1 自定义类型

• 形式：typedef 类型 别名；
  • typedef int SER;
    • int 是本名 SER是别名（都是大写）
    • SER a；就相当于 int a;了

12.2 结构体

12.2.1 结构体的定义

• 形式：struct student

  ​ {成员列表}： 结构体中成员类型可以相同也可以不同

  • struct：结构体类型关键字
  • student：结构体名/类型名
  • struct student：结构体类型/结构体类型名

12.2.2 结构体变量的定义

• 先说明结构体类型，再定义结构体变量

  struct student{
      int num;
      char name[8]
  };							//分号很重要
  sruct student a,*b,c[3];

• 说明结构体类型的同时定义结构体变量

  struct student{
      int num;
      char name[8]
  }a,*b,c[3];

• 直接定义结构体变量

  struct{
      int num;
      char name[8]
  }a,*b,c[3];

• 使用用户自定义类型定义结构体变量

  typedef struct student{			//struct student是本名
      int num;
      char name[8]
  }STD;							//STD是别名
  STD a,*b,c[3];					//等价 于sruct student a,*b,c[3];

12.2.3 结构体变量的初始化

• 结构体变量的初始化

  struct data{
      int a;
      float b;
  }s={12,24.56};

• 结构体数组的初始化

  struct data{
      int a;
      float b;
  }c[2]={1,2,3,4};

• 结构体变量所占空间大小

  • 等于所有成员只和

  • ==结构体指针变量占空间大小分为两种情况==

    • TC系统（默认）下：2个字节

    • VC系统下：4个字节

      系统	指针	int	其他
      TC	2B	2B	不变
      VC	4B	4B	不变

12.2.4 结构体成员引用

1. 结构体变量名.成员名字
2. 结构体指针->成员名
3. *（结构体指针名）.成员名
   • “.”：成员运算符 “->”：指向运算符

12.3 链表

1. 处理动态链表所需的函数

   • 函数malloc（）和calloc（）为链表分配存储空间，free（）释放存储空间

     • malloc（）分配变量

       int *p;
       p=(int*)malloc(sizeof)(int);

     • calloc（）分配数组

2. 指向自身的结构体类型

   struct node{
       int data;
       struct node *next;
   };

3. 静态链表

   1. 定义指向自身的结构体类型（数据结构里的链表）

      struct node{
          int data;
          struct node *next;
      };

   2. struct node a,b,c,*p; 定义结构体变量

   3. a.data=1；b.data=2;c.data=3; 给数据域赋值

   4. a.next=&b;b.next=&c;c.next=NULL; 连接

4. 链表的插入与删除

   1. 将q节点插入到p节点后

      q->next=p->next; 先连后面

      p->next=q; 再连前面

   2. 将q节点从链表中删除（q节点前为p节点）

      p->next=q->next;

      free(q);

13 位运算

1. 位运算符和位运算
   1. 按位与&：有0为0，全1为1
   2. 按位或|：有1为1，全0为0
   3. 按位异或^：相同为0，不同为1
   4. 按位取反~：相当于-(x+1)
   5. 位左移<<：左移几位乘几个2
   6. 位右移>>：右移几位除几个2（舍弃余数）

	0	1
按位&	清零	不变
按位|	不变	变1
按位^	不变	求反

• ==位运算针对的都是二进制数==
  • 例题

#include <stdio.h>
main (){
    char a,b;
    a=4|3;					//4=>0100  3=>0011
    b=4&3;
    printf("%d %d\n",a,b);	//a=7 b=0
}

• 优先级：~，<<,>>,&,^,|
  • 例题

#include <stdio.h>
main (){
    char a=3,b=6，c;		//a=00000011
    c=a^b<<2;			//先算b<<2=24	b=00011000
    printf("%x",c);		//00011011	输出为1b，输出无前导
}

14 文件

• 根据数据的组织形式，C语言将文件分为**ASCII码/文本文件和二进制文件**两种类型

• 文件指针

  • FILE 文件指针名

    FILE *fp；

• 文件函数

  • 文件的打开

    FILE *fp；

    fp=fopen(“a.txt”,”r”);

    以只读的方式打开文件a.txt，返回一个文件型指针，若没有打开文件返回空指针NULL。

  • 文件的关闭

    fclose（fp）；

    关闭文件指针fp所指的文件

  • 读字符函数 fgetc()

    ch=fgetc(fp);

    从文件指针fp所指的文件中读取一个字符赋给字符变量ch。

  • 写字符函数 fputc（）

    fputc(‘a’,fp)；字符常量

    fputc(ch,fp)；字符变量

    讲一个字符写入到文件指针fp所指的文件中

  • 读字符串函数 fgets（）

    fgets（str,11,fp）;

    从fp所指的文件中读取**10个字符放入字符输入数组str中，在最后一个（第10个）字符后面加1个‘/0’**

  • 写字符串函数 fputs（）

    fputs(“abcd”,fp);字符串常量

    将字符串写入到fp所指的文件中

    fputs(str,fp);字符数组名

    将字符数组中的字符串写入到fp所指的文件中.

  • int a,b;

    fscanf(fp,“%d%d”,&a&b);

    从fp所指的文件中读取两个十进制整数分别赋给整形变量a和b。

  • int a,b;

    fprintf(fp,“%d%d”,&a&b);

    将整形变量a和b的值以十进制的形式写入到fp所指的文件夹中

  • 数据块读函数fread（）;

    fread（a,4,5,fp）；

    从fp所指的文件中，每次读4个字节的数据放入数组a中，连续读5次。

  • 数据块写函数fwrite（）；

    fwrite（a,4,5,fp）

    从a数组的首地址开始，每次将4个字节的数据写入到fp所指的文件中，连续写5次。

  • rewind（）；

    将fp所指文件的位置**指针（插入点）移动到文件首部****

  • feof（fp）；

    • 判断fp所指的文件是否处于结束位置，处于结束位置返回1，否则返回0
    • E0F含义是指文件结束标志

  • fseek（文件指针，位移量，起始点）；

    fseek(fp,0L,SEEK_SET);等价于rewind（fp）

    fseek(fp,0L,2);指针位于文件末尾

  起始点	表示符号	数字表示
  文件首	SEEK_SET	0
  当前位置	SEEK_CUR	1
  文件末尾	SEEK_END	2

打开方式	具体含义
“rt”	只读打开一个文本文件，只允许读数据。
“wt”	只写打开或建立一个文本文件，只允许写数据。
“at”	追加打开一个文本文件，并在文件末尾写数据。
“rb"	只读打开一个二进制文件，只允许读数据。
“ wb ”	只写打开或建立一个二进制文件，只允许写数据。
“ ab”	追加打开一个二进制文件，并在文件末尾写数据。
“rt+”	读写打开一个文本文件，允许读和写。
“wt+”	读写打开或建立一个文本文件，允许读写。
“at+”	读写打开一个文本文件，允许读，或在文件末追加数据。
“rb+”	读写打开一个二进制文件，允许读和写。
“wb+”	读写打开或建立一个二进制文件，允许读和写。
“ab+”	写打开一个二进制文件，允许读，或在文件末追加数据。

• ==r 读 w 写 a 追加 b二进制文件 t 文本文件 +可读可写==

  • 新建的文件用w开头
  • 若要打开一个***==新的==***二进制文件，该文件要既能读也能写，则文件方式字符串应是“wb+”

  #include<stdio.h>
  main()
  { FILE *fp;
  char str[10];
  fp=fopen("myfile.dat","w"); //新建文件夹
  fputs("abc",fp);			//字符串abc写进去
  fclose(fp);					//关上
  fp=fopen("myfile.dat","a+");//追加形式打开可读可写
  fprintf(fp,"%d",28);		//把28写入
  rewind(fp);					//回到开头u
  fscanf(fp,"%s",str);		//读字符串
  puts(str);					//写字符串abc28
  fclose(fp);					//关闭文件
  }