【C语言复习笔记】一些要点

【C语言复习笔记】一些要点

按学校教材复习的，整理的是我不熟悉的地方

最近C用的好少，快忘完了就赶紧整理一下（Python真好玩）

第一章 初识C语言

存储器

内存容量的大小，取决于地址总线的数量

\(1B=8bits\)

\(1KB=2^{10}B\)

往后，依次MB, GB, TB, PB, EB, ZB, YB，均为\(2^{10}\)递增

计算机程序与计算机语言

  • 开发C程序的完整过程：

· 编辑（生成拓展名为.c的源文件）

· 编译（生成拓展名为.obj的目标文件）

· 链接（生成拓展名为.exe的可执行文件）

· 运行

  • 第一个结构化程序设计语言：PASCAL

第二章 数据类型

C源程序的组成

函数是C语言源程序的基本单位

一个函数的完整定义由函数首部和函数体两部分构成

常量

整型常量

八进制：数字0开头

十六进制：0X或0x开头

实型常量

表示方式：小数形式、指数形式

如：3.14; 3.9e8; 6.8E-5; 9.0e+20等

实型常量默认double类型

字符常量

表示方式：一堆单引号将一个字符括起来；单引号括起的以‘\’开头的字符序列

ASCII码表中，字符分为可打印字符和控制字符

特殊的转义字符：

'\ddd'：1到3位八进制ASCII码值所代表的字符

‘\xhh’：1到2位十六进制ASCII码值所代表的字符

ASCII码表中字符：

Space-32

A-65

a-97

小写->大写：-32

字符串常量

双引号括起来的零个或多个字符序列，后面有系统添加的\0

  • 字符串常量的实际字符数总是比其双引号中的字符数多1

符号常量

用#define宏定义的东西

变量

scanf用法

%5d：限制阈宽为5

  • 注意：scanf没有%5.2d这种用法

print用法

例：

  • printf("%5d",1234567) 输出：1234567

  • printf("%5.2d",123.1254) 输出： 123.13

注

  • char - 1 Byte

  • int - 4 Byte

  • double - 8 Byte

  • 冯·诺伊曼提出了程序存储的思想

  • 计算机五大基本组成部件：

​ 运算器，控制器，存储器，输入设备，输出设备。

第三章 运算符

一些运算符优先级

  • ! : 2
  • && : 11
  • || : 12
  • ==, != : 7

注意前++与后++

数据类型转换

  • 赋值中自动类型转换：将右边表达式的值转成左边变量的类型
  • 强制类型转换：如 (int)a

注

1.sizeof是一个运算符，不是一个函数。

第四章 程序流程

注意switch有一个掉落原则，只要碰到符合的case，若case后没有break就会一直执行。

如：写出下面程序的运行结果 （Hello, World!）

#include <stdio.h>
int main()
{
  int x=1,y=1,z=1;
  switch(x)
  {
    case 1:
      switch(y)
      {
        case 0:printf("Hi");
        case 1:printf("Hell");break;
        case 2:printf("o");
      }
    case 0:
      switch(z)
      {
        case 0:printf("wor");break;
        case 1:printf("o, Wo");
        case 2:printf("rld");
      }
    default: printf("!");
  }
  return 114514;
}

下面是一些经典程序：

打印倒三角：

int i, j;
for(i = 0; i < 5; i++)
{
    for(j = 0; j < i; j++)
        printf(" ");
    for(j = 9 - 2 * i; j > 0; j--)
    {
        printf("*");
    }
    printf("\n");
}

打印九九乘法表：

#include <stdio.h>

int main(void)
{
    int i,j,k;
    for(i=1; i<=9; i++)
    {
        for(j=1; j<=i; j++)
        {
            printf("%d*%d=%d\t", j, i, i*j);
        }
        printf("\n");
    }
    return 0;
}

注

1.下面程序的运算结果是 （4，4）

  int a,b=0;
  for(a=0; a++<=2;);
    b+=a;
  printf("%d,%d",a,b);

第五章 函数

函数调用的完整过程：

  • 转向
  • 传参
  • 执行
  • 返回
  • 继续

变量作用域

定义在函数内部：局部变量；外部：全局变量

变量存储类型

全局变量：生命周期为整个运行期间，static类型仅限本文件使用，非static的加上extern声明后其他文件可以使用

静态局部变量的生命周期等于全局变量，作用域等同于自动局部变量

常见题

判断质数

int judgePrime(int n)//不属于正整数返回-1，不是质数返回0，是质数返回1
{
    int i,k,judge=1;
    if(n<=0) return -1;
    if(n==1) return 0;
    if(n==2||n==3) return 1;
    k=(int)sqrt(n);
    for(i=2;judge&&i<=k;i++)
        judge=n%i;
    return judge;
}

求最大公因数（递归）

int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}

注

1.‎若函数定义时不指明函数类型，则其默认的返回值类型是int

第六章 数组

没啥东西，熟悉常用算法即可

下面是一些常见算法

输出数组

int Array_print(int * a, int n) //n:numbers
{
    int * p = a;    	//工作指针p
    while(p - a < n)    //扫描数组
        printf("%d ", *p++);
    printf("\n");
    return 1;
}

插入数组元素

int Array_insert(int * a, int n, int m, int x)//在下标m后插入一个数组元素x; n:numbers
{
    int i=n-1;
    while(i>m)	//移位
        a[i--]=a[i-1];
    a[m+1] = x;	//插入
    return 1;
}

删除类似插入，不细嗦了。

寻找最值

int Array_findMinandMax(int * array, int n, int mode)//n:numbers; mode: 0-min;1-max
{
    int * a = array;	//工作指针a
    int max = *a, min = *a;
    while(a - arr < n)	//扫描数组
    {
        if(*a > max)  max = *a;
        if(*a < min)  min = *a;
        a++;
    }
    switch(mode)
    {
        case 0: return min;
        case 1: return max;
        default: return 114514;
    }
}

排序

传统冒泡排序

int * Array_bubbleSorting(int * a, int n, int mode)
{
    int i,j,temp;
    int * p = a;    //输出的数组p
    if(mode == 0)   //正序
    {
        for(j = 0; j<n-1; j++)  //共n-1趟冒泡
            for(i = 0; i<n-1; i++)  //每一趟冒泡
            {
                if(p[i] > p[i+1])
                {
                    temp = p[i];
                    p[i] = p[i+1];
                    p[i+1] = temp;   //前一个大就值交换
                }
            }
    }
    if(mode == 1)   //逆序
    {
        for(j = 0; j<n-1; j++)  //共n-1趟冒泡
            for(i = 0; i<n-1; i++)  //每一趟冒泡
            {
                if(p[i] < p[i+1])
                {
                    temp = p[i];
                    p[i] = p[i+1];
                    p[i+1] = temp;   //前一个小就值交换
                }
            }
    }
    return p;
}

选择法排序

int * Array_chooseSorting(int * a, int n, int mode)//n:numbers; mode:0-正序, 1-逆序
{
    int * p = a;//输出的数组p
    int i,j,temp,index;
    if(mode == 0)//正序
    {
        for(i=1; i<n; i++)//共进行n轮
        {
            index = i-1;//初始化index，假设p[i-1]为最小
            for(j=i; j<n; j++)//每一轮选出该轮最小值对应下标给index
            {
                if(p[j] < p[index])
                    index = j;
            }
            temp = p[index];   //交换
            p[index] = p[i-1];
            p[i-1] = temp;
        }
    }
    if(mode == 1)//逆序
    {
        for(i=1; i<n; i++)//共进行n轮
        {
            index = i-1;//初始化index，假设p[i-1]为最大
            for(j=i; j<n; j++)//每一轮选出该轮最大值对应下标给index
            {
                if(p[j] > p[index])
                    index = j;
            }
            temp = p[index];   //交换
            p[index] = p[i-1];
            p[i-1] = temp;
        }
    }
    return p;
}

注

1.getchar()会读取回车符

int a[][4] = {0};//这种赋值将所有赋值为0，是正确的用法。

第七章 指针

C语言精华所在。

上面的数组里已经用了不少指针了。

注

  1. int a[10]; sizeof(a)出来是40

第八章 字符串

没啥，跟数组差不多。

一些string.h中的库函数：

  • int strlen(const char * str);
  • char * strcpy(char * destination, const char * source)；
  • char * strcat(char * destination, const char * source);
  • int strcmp(const char * s1, const char * s2); //前大返回1，后大返回-1
  • char * strupr(char * str);
  • char * strlwr(char * str);

注

1.下列代码输出结果为（） （123）

#include <stdio.h>
int main()
{
  char * str = "123\0abdc";
  printf("%s",str);
  return 114514;
}

可以发现，C在输出字符串时，只要碰到\0就会停止输出，不管\0后面是啥。

2.下面的字符串初始化是错的：

char str[5]="good!";//应该把5改为6

因为 “good!” 需要的存放空间为5+1=6，多出来的1是留给\0。

3.‎strlen("b\013c\xac\\abc\n")的值为（） （9）

​ 因为代码中字符串包含 ’b’, ’\013’, ’\c’, ’\xac’, ’\\’, 'a' ’b’, ’c’, '\n' 共9个有效字符

4.下面程序的输出结果是（） （W, ）

  char str1[6] = "Hello";
  char str2[13] = "12345,World!";
  strcpy(str2,str1);
  printf("%c,%c",str2[6],str2[5]);

5.下面程序的输出结果是（） （Hello）

  char str1[6] = "Hello";
  char str2[13] = "12345,World!";
  strcpy(str2,str1);
  puts(str2);

​ 综合4，5可见strcpy的操作逻辑。

第九章 编译预处理与多文件

编译预处理指令都以#开头

宏定义

分为无参宏和带参宏

带参宏：()中为参数列表

注

1.宏定义将一个标识符定义为一个字符串，不进行数据类型的处理。

2.对于以下宏定义：

‍ #define M(x) x*x

‍ #define N(x, y) M(x)+M(y)

执行语句z=N(2, 2+3);后，z的值是（） （15）

‍（宏定义经典题目）

第十章 结构体

EZ~

第十一章 文件

（因为当时没听课所以就多写了一些（）

C语言中文件分为两种：文本文件（ASCII文件）与二进制文件。

对文件进行操作，首先要定义1个文件指针。

打开文本文件方式（二进制+b）：

  • r：输入方式打开
  • w：输出方式打开
  • a：输出追加方式打开
  • r+：读/写方式打开
  • w+：读/写方式建立
  • a+：读/写追加方式打开

相关库函数：

  • FILE * fopen(char * filename, char * mode); // 打开文件
  • int fclose(FILE * fp); // 关闭文件
  • int fputc(int c, FILE * fp); // 将字符写入文件
  • int fgetc(FILE * fp); // 从文件读出一个字符，位置指针自动后移一个字符
  • int feof(FILE * fp); // 位置指针指向文件末尾返回非0，其余0。位置指针同时后移
  • int fputs(const char * s, FILE * fp); // 将字符串写入文件
  • char * fgets(char * s, int n, FILE * fp); // 从文件读取字符串
  • int fprintf(FILE * fp, const char * format, ...); // 格式化写入
  • int fscanf(FILE * fp, const char * format, ...); // 格式化读取
  • int fwrite(const void * buffer, int size, int n, FILE * fp); // 块数据写入
  • int fread(void * buffer, int size, int n, FILE * fp); // 块数据读取
  • ......（后面不考所以不写啦）

读取旧文件控制循环：

/*用feof函数读取*/
ch = fget(fp);
while(!feof(fp))
{
    putchar(ch);
    ch = fgetc(fp);
}

/*标准读取*/
while((ch = fgetc(fp)) != EOF)
{
    putchar(ch);
}
posted @ 2023-02-26 16:49  Akasa  阅读(551)  评论(0)    收藏  举报