江苏大学考研885程序设计 - 填空选择知识点

刺骨的言语ヽ痛彻心扉 2022-12-11 03:16 512阅读 0赞

### 江苏大学考研专业课备考代码 ###

*   *  这个暂时还不能完全放出来！万一被对手看到了怎么办！ --2020.10.3
 *  预备知识
 *   *  C语言32个关键字
     *  C语言运算符优先级和结合性
     *  常用数学函数
 *  选择、填空
 *   *  常规知识点
     *  优先级知识点
     *  指针知识点
     *  文件操作知识点
     *  数据类型
     *  函数知识点
     *  字符串赋值操作
     *  int main(int argc, char\*\* argv) 的含义
 *  程序阅读题
 *   *  static 注意点
     *  strcmp 字符串比较规则
 *  错题

> [江苏大学考研885程序设计 - 填空选择知识点][885_ -]  
> [江苏大学考研885程序设计 - 编程题笔记][885_ - 1]  
> [江苏大学考研885程序设计 - 课后习题][885_ - 2]

## 这个暂时还不能完全放出来！万一被对手看到了怎么办！ --2020.10.3 ##

# 预备知识 #

## C语言32个关键字 ##

查阅用~

auto	声明自动变量
    break	跳出当前循环
    case	关语句分支
    char	声明字符型变量或函数返回值类型
    const 	声明只读变量
    continue 结束当前循环，开始下一轮循环
    default	开关语句中的“默认”分支
    do 		循环语句的循环体
    double 	声明双精度浮点型变量或函数返回值类型
    else 	条件语句否定分支（与 if 连用）
    enum 	声明枚举类型
    extern  声明变量或函数是在其它文件或本文件的其他位置定义
    float   声明浮点型变量或函数返回值类型
    for	 	一种循环语句
    goto	无条件跳转语句
    if		条件语句
    int	 	声明整型变量或函数
    long 	声明长整型变量或函数返回值类型
    register 声明寄存器变量
    return 子程序返回语句（可以带参数，也可不带参数）
    short	声明短整型变量或函数
    signed	声明有符号类型变量或函数
    sizeof	计算数据类型或变量长度（即所占字节数）
    static 	声明静态变量
    struct	声明结构体类型
    switch 	用于选择语句
    typedef	用以给数据类型取别名
    unsigned 声明无符号类型变量或函数
    union	声明共用体类型
    void	声明函数无返回值或无参数，声明无类型指针
    volatile 说明变量在程序执行中可被隐含地改变
    while 	循环语句的循环条件

## C语言运算符优先级和结合性 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center 2]

## 常用数学函数 ##

int abs (int j);  // 用来计算参数j的绝对值, 然后将结果返回
    double fabs(double x) // 返回 x 的绝对值。
    double exp(double x); // 用来计算以e为底的x次方值，即e^x值，然后将结果返回。
    double log10(double x); // 对数函数log,以bai10为底
    double log(double x); // 对数函数log,以e(2.71828)为底

计算  l o g a b log\_a^b logab 需要利用换底公式：`logab = log(b) / log(a)`![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center 3]

#include<stdio.h>
    #include<math.h>
    int main(){  
    	printf("%f\n",log(10)); //以e为底的对数函数 
    	printf("%f\n",log10(100)); //以10为底的对数函数 
    	printf("%f\n",log(8)/log(2)); //计算log2^8,运用换底公式 
    	printf("%f\n",exp(1)); //计算自然常数e
    	return 0;
    }

# 选择、填空 #

## 常规知识点 ##

1、任何算法都可以用 **顺序结构**、**选择结构**、**循环结构** 这三种基本结构及其组合来描述。

2、C 程序可以由一个或多个函数组成。（构成C程序的基本单位是**函数**）

3、能将高级语言编写的源程序转换为目标程序的是：**编译程序**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]

4、若有函数内部说明：int a\[3\]\[4\]；则数组a中各元素( C)。

*  A．可在程序的运行阶段得到初值0
 *  B．可在程序的编译阶段得到初值0
 *  C．不能得到确定的初值
 *  D．可在程序的编译或运行阶段得到初值0

5、以下语句是正确的：

while(x = y) x++;

--------------------

6、下列语句：

n = (4 > 4 - !2) && (2 > 1) || (2 && 6);

执行后 n 的值为：1

解答：如改成下面这样则是 0；

n = (4 > 4 - !2) && (2 > 1);

可见 `||` 哪怕在最后，只要满足即为真。

--------------------

7、C(C++)语言规定，函数的返回值的类型是：(D)  
A、由调用该函数时的主调函数类型所决定。  
B、由 return 语句中的表达式类型所决定。  
C、由调用该函数时系统临时决定。  
D、由定义该函数时所指定的数据类型决定。

--------------------

8、若有：`char str[2][10] = {"C++", "Basic"};` 则 `sizeof(str)` 的结果为：20，输出 `str[1][1]` 为 a，输出 `str[1]+1` 为 asic。

解：`sizeof` 作用是求类型、变量占用内存空间的大小，用于字符串并非求字符串的长度。  
对二维数组使用 `sizeof` 即求二维数组占用的空间，相当于 `行数 * 列数 * 每个元素占用的空间(sizeof元素类型)`，则本题中的 `sizeof(str)` 为 `2*10*1 = 20`(char类型)。

`str[1]` 代表第二个字符数组的首地址即`Basic` 的首地址，`str[1]+1`代表第二个字符数组的首地址+1即`asic` 的首地址，则输出 `str[1]+1` 为 `asic`

--------------------

9、有一个 `int` 型变量，在程序中**使用频度很高**，最好定义为：`register`。

--------------------

10、假定已知变量 a, b, c, ch 有定义，`int a=3,b=5,c=0; char ch='0';` 则表达式 `ch=3||(b+=a*c)||c++`的值是1，该表达式运算过后，c=0；

解：`||` 操作如果前面成为真，则不再判断后面，整个表达式直接返回真。`ch=3` 这种赋值操作返回为真。

--------------------

11、若 `float x=2.5, y=8.2, z=1.4; int a=3,b=5;` 则表达式 `x=z*b++,b=b*x,b++` 的值是：42。

解答：注意这是 **逗号表达式**，并且最后是 `b++`，则先返回 `b` 的值再执行 ++。

--------------------

12、编译预处理包含：：**文件包括（\#include）**、**宏定义(\#define)**、**条件编译**

--------------------

13、枚举类型的定义：

#include<stdio.h>
    enum Color { red, yellow, blue, white, black}; // 定义枚举类型
    enum Color w = white;
    int main() { 
        printf("%d", w); // 3
        return 0;
    }

也可以定义枚举类型的同时定义变量：

enum Color { red, yellow, blue, white, black} w = white;

## 优先级知识点 ##

1、`*(乘号)`、`<=`、`!=`、`!`、`&&` 运算符中，优先级从高到低是：`!`、`*`、`<=`、`!=`、`&&`

2、`+`、`>=`、`->`、`!`、`&&` 中，优先级从高到低是：`->`、`!`、`+`、`>=`、`&&`

3、`&&`、`!`、`+`、`=` 运算符中，优先级最低的是：`=`

4、优先级：算术运算 > 关系运算 > 逻辑运算(`!`除外) > 赋值运算

5、对于以下结构定义：

struct sk { 
    	int len;
    	char *str;
    } a[5], *p = a;

`++p->str` 中的 `++` 加在 指针str上

解答：C语言中 `->` 的优先级 高于 `++`; 相当于 `++(p->str)`，指针先指向元素值，再自增；

6、假定 p 所指对象的指为 20，p+1 所指对象的值为 60，则执行 `*p++;` 语句后，p 所指对象的值为：60；

解答：`*` 和 `++` 优先级相同，从右往左运算，`*p++` 的效果等同于 `*(p++)`，先执行 `p++` 后再取值，所以指针后移一位后取值，取到的值为 60。  
如果改成 `(*p)++` 则答案变成 21。

## 指针知识点 ##

1、若有以下说明和语句：

int a[10], *p1, *p2;
    p1 = a;
    p2 = &a[5]; // p2 = a + 5; 等价

则 `p2 - p1` 的值为：**5**

2、有以下程序：

#include<stdio.h>
    #include<stdlib.h>
    
    int main() { 
        char *p, *q;
        p = (char *)malloc(sizeof(char) * 20);
        q = p; // p 和 q 指向同一块内存
        scanf("%s%s", p, q); // p接收了abc, q接收了def, 后输入的覆盖了前面的
        printf("%s %s", p, q);
        return 0;
    }

若从键盘输入：`abc def<回车>`，则输出结果是：`def def`

解：`p` 和 `q` 指向同一块堆内存，后输入的覆盖了前面输入的内容。

*  `scanf() 和 %s` 只能录入连续的字符串，遇到空格就结束了；
 *  区别于 `gets()` ) 可以录入带空格的字符串，遇回车才结束。

3、若有定义：

int a[3][4], *p;

则对数组元素 `a[i][j]` (0<=i<3,0<=j<4)正确的引用是：`*(*(a+i)+j)`

解答：`a[3][4]` 定义了一个二维数组，`a`表示二维数组a的首地址；  
`a[0]`、`a[1]` 看作一维数组，`a[0]` (或 `*a`) 代表一维数组 `a[0]` 的首地址；  
`a[0][0]` (或`*(*a)`) 代表一维数组 `a[0]` 的第一个元素；  
`*(a+1)+1` 也就是 `a[1]+1`，即一维数组 `a[1]` 的第二个元素，即 `a[1][1]` 的地址；  
`*(*(a+1)+1)` 就是 `a[1][1]` 的值；

例：

#include<stdio.h>
    
    int main() { 
        int a[3][4];
        for (int i = 0; i < 3; i++) { 
            for (int j = 0; j < 4; j++) { 
                a[i][j] = i+j;
            }
        }
    
        for (int i = 0; i < 3; i++) { 
            for (int j = 0; j < 4; j++) { 
                printf("a[%d][%d]=%d\t", i, j, *(*(a + i) + j));
            }
            printf("\n");
        }
    }

a[0][0]=0       a[0][1]=1       a[0][2]=2       a[0][3]=3
    a[1][0]=1       a[1][1]=2       a[1][2]=3       a[1][3]=4
    a[2][0]=2       a[2][1]=3       a[2][2]=4       a[2][3]=5

4、若有定义 `char s[10]`，则下面不能表示 `s[1]` 地址的是：(B)  
A、`s+1`  
B、`s++`  
C、`&s[0]+1`  
D、`&s[1]`

解：  
`s`是数组首元素地址，**地址** 是 **指针常量**，可以输出 `s+1` 代表第二个元素的地址，但是不可以执行 `s++`，因为 `s++` 等价于 `s+=1` ，**地址是常量，不能修改它的值**。  
A 中 `s+1` 代表数组第二个元素的地址，即 `s[1]` 的地址。  
B 中 `s++` 是错误的，不能修改地址的值。  
C 中 `&s[0]+1`，等价于 `s+1`，正确。  
D 中 `&s[1]` 表示 数组第二个元素的地址。

#include<stdio.h>
    int main() { 
        char s[10];
        printf("%x\n", s+1);    // 61fe17
        // printf("%x\n", s++); // 错误
        printf("%x\n", &s[0]+1);// 61fe17
        printf("%x\n", &s[1]);  // 61fe17
        return 0;
    }

## 文件操作知识点 ##

1、C(C++) 语言中的文件类型划分为 **ASCII 文件** 和 **二进制文件** 两种。

2、C程序中，可把整型数以**二进制形式**存放到文件中的函数时：fwrite函数

3、当文件指针已处在结尾时，函数 `feof()` 返回值是 非0；

*  `feof()` 用来判断文件是否处于结束位置，如果读文件结束，`feof()`为非0值，否则为0。

## 数据类型 ##

1、设有定义：

char w;int x;float y;

则表达式 `w*x - 3.0*y` 值的数据类型为：double

解：这道题很容易做成 float，在C语言中 `小数(3.0)` 默认是 `double` 类型，而非 `float`。

2、下面正确的字符常量是：(C)  
A、`"c"`  
B、`'\\''`  
C、`'w'`  
D、`''`

解：A 中使用了双引号，是字符串不是字符常量。  
B 中多了一个反斜杠，`'\\'` 表示反斜杠字符，`'\''` 表示引号字符。  
C 是正确的。  
D：C语言的 **空字符** 是 `\0` 而非 `''`(编译不通过)。

3、若有定义语句：`int a = 7; float x = 2.5, y = 4.7;` 则表达式 `x+a%3*(int)*(x+y)/4` 的值为 3.500000，执行 `a+=a-=a*=a;` a 的值为：0。

解答：第一问很容易写成 `3.5`，`float` 和 `double` 都默认保留 6 位小数。

#include<stdio.h>
    int main() { 
        float a = 123456; // 123456.000000
        double b = 654321; // 654321.000000
        printf("%f\n%lf", a, b);
        return 0;
    }

## 函数知识点 ##

1、以下函数调用语句中，含有的实参个数是：2

calc(exp1, (exp3,exp4,exp5));

解：原理是**逗号表达式**（从左往右计算，最终返回最右的值），本语句相当于 `calc(exp1, exp5);`

## 字符串赋值操作 ##

char *s = "hello world";
    // 下列写法也可以
    char *s;
    s = "hello world";

char s[] = "I love China!";
    // 下列写法是错误的
    /** char s[10]; s = "hello world!"; // 数组名是地址,是常量,不能被赋值 **/

char c[10] = { 'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm'};
    // 下列写法是错误的
    /** char c[10]; c = {'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a', 'm'}; // 数组名是地址,是常量,不能被赋值 **/

总结：指针直接赋值、先定义再赋值都可以；数组不能先定义再赋值；

## int main(int argc, char\*\* argv) 的含义 ##

问题：将程序prog.c编译链接后运行：`prog -nla hello world则*(*(argv+2))` 是( )  
A.‘p’  
B.’-’  
C.‘h’  
D.‘w’

解答：  
C语言代码的完整框架如下，平时我们常常省略 `main()` 括号中内容；

#include <stdio.h>
    int main(int argc, char** argv) { 
    // 或 int main(int argc, char* argv[])
        return 0;
    }

C语言的 main 函数拥有两个参数

*  `int` 类型的 `argc` 参数：表示 **命令行参数的个数**；
 *  `char**` 类型 `argv` 参数：指向一个 **字符串数组**，该数组存储 **命令行参数内容**。  
    （注意：程序本身的名字为命令行的第一个参数）

验证：

#include <stdio.h>
    int main(int argc, char** argv) { 
        printf("%d\n", argc);		// 输出argc的值，也就是命令行参数的个数（包括程序名）
        for (int i = 0; i < argc; i++) { 
            printf("argv[%d] = %s\n", i, argv[i]); // 输出每个数组的值
        }
        printf("*(*(argv+2)) = %c\n", *(*(argv+2))); // 第3个参数的第1个值, 即'hello'的'h'
        return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_15_color_FFFFFF_t_70_pic_center]

# 程序阅读题 #

## static 注意点 ##

`static` 是**静态变量**，定义时必须**初始化**，以后的赋值都是不起作用的。

#include<stdio.h>
    
    void test() { 
        int x = 0;
        static int y = 5; // 只有第一次调用 test() 时 y被赋值了, 后续再调用无效
        y  += ++x;
        printf("%4d %4d", x, y);
    }
    
    int main() { 
        test();
        test();
    }

1    6   1    7

## strcmp 字符串比较规则 ##

#include<stdio.h>
    #include<string.h>
    
    void f(char p[][10], int n) { 
        char t[20];
        int i, j;
        for (i = 0; i < n - 1; i++) {  // 冒泡排序
            for (j = i + 1; j < n; j++) { 
                if (strcmp(p[i], p[j]) < 0) { 
                    strcpy(t, p[i]);
                    strcpy(p[i], p[j]);
                    strcpy(p[j], t);
                }
            }
        }
    }
    
    int main() { 
        char p[][10] = { "abc", "aabdfg", "abbd", "dcdbe", "cd"};
        f(p, 5);
        printf("%d\n", strlen(p[0]));
    }

这是利用冒泡排序对下列数组进行排序的程序：

['a', 'b', 'c']
    ['a', 'a', 'b', 'd', 'f', 'g']
    ['a', 'b', 'b', 'd']
    ['d', 'c', 'd', 'b', 'e']
    ['c', 'd']

排序后的数组为：

['d', 'c', 'd', 'b', 'e']
    ['c', 'd']
    ['a', 'b', 'c']
    ['a', 'b', 'b', 'd']
    ['a', 'a', 'b', 'd', 'f', 'g']

程序要求是输出排序后第一行数组的长度，所以答案是 5。

需要注意的是C语言中字符串的比较规则：**从左往右，每个字符逐个比较**；  
`strcmp("a", "bcdef")` 返回值 > 0；  
`strcmp("abc", "aba")` 返回值 > 0；  
`strcmp("abcd", "abce")` 返回值 < 0；

# 错题 #

![在这里插入图片描述][2020122620305851.png]

`#include` \+ `<文件名>`，预处理程序在**标准目录下**查找指定的文件  
`#include` \+ `"文件名"`，预处理程序**首先在引用被包含文件的源文件所在的目录中寻找指定的文件，如查找不到，再按系统指定的标准目录查找**。

[885_ -]: https://blog.csdn.net/weixin_43734095/article/details/108839137
[885_ - 1]: https://blog.csdn.net/weixin_43734095/article/details/109202068
[885_ - 2]: https://blog.csdn.net/weixin_43734095/article/details/109443232
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/33f84986e26d43e79ddc37ad61e6846d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/c556421608bf434c882dec9de744be7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/32d255f303624e8aa082d301f4c2e852.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/f3c6b18ae137492388f693b802c0ec8d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]: /images/20221123/118912e194f44b359c939474faa84901.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_15_color_FFFFFF_t_70_pic_center]: /images/20221123/bc94752292604e77837696d46f2764f7.png
[2020122620305851.png]: /images/20221123/02a0acc72db345eeb09061f85a0dc9b3.png