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

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

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

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

1|1第一章 初识C语言

1|0存储器

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

$1B=8bits$

$1KB=2^{10}B$

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

1|0计算机程序与计算机语言

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

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

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

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

· 运行

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

1|2第二章 数据类型

1|0C源程序的组成

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

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

1|0常量

1|0整型常量

八进制：数字0开头

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

1|0实型常量

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

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

实型常量默认double类型

1|0字符常量

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

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

特殊的转义字符：

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

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

ASCII码表中字符：

Space-32

A-65

a-97

小写->大写：-32

1|0字符串常量

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

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

1|0符号常量

用#define宏定义的东西

1|0变量

1|0scanf用法

%5d：限制阈宽为5

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

1|0print用法

例：

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

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

1|0注

• char - 1 Byte

• int - 4 Byte

• double - 8 Byte

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

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

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

1|3第三章 运算符

1|0一些运算符优先级

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

注意前++与后++

1|0数据类型转换

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

1|0注

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

1|4第四章 程序流程

注意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|0注

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

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

1|5第五章 函数

函数调用的完整过程：

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

1|0变量作用域

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

1|0变量存储类型

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

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

1|0常见题

1|0判断质数

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

1|0求最大公因数（递归）

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

1|0注

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

1|6第六章 数组

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

下面是一些常见算法

1|0输出数组

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

1|0插入数组元素

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

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

1|0寻找最值

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

1|0排序

1|0传统冒泡排序

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

1|0选择法排序

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|0注

1.getchar()会读取回车符

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

1|7第七章 指针

C语言精华所在。

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

1|0注

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

1|8第八章 字符串

没啥，跟数组差不多。

一些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|0注

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|9第九章 编译预处理与多文件

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

1|0宏定义

分为无参宏和带参宏

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

1|0注

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

2.对于以下宏定义：

‍ #define M(x) x*x

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

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

‍（宏定义经典题目）

1|10第十章 结构体

EZ~

1|11第十一章 文件

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

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);
}

__EOF__

本文作者：Asaka
本文链接：https://www.cnblogs.com/Asaka-QianXiang/p/17157014.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！