倾低督设惹蛔桃缓患胸竞狭衬
第1周——原来内存也可以这么玩我是指针我怕谁
指针和内存
1、判断题：
指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
A: 正确
B: 错误
答案: 错误
2、判断题：
用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。
A: 正确
B: 错误
答案: 错误
第1周测验
1、单选题：
下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下：Enter array size:8↙array[0]=0array[1]=10array[2]=20array[3]=30array[4]=40array[5]=50array[6]=60array[7]=70按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p,n,i;
printf(“Enter array size:”);
scanf(“%d”,&n);
__________________;
for(i=0;i<n;i++)
{
____________;
}
for(i=0;i<n;i++)
{
_______________;
}
free(p);
return 0;
}
A: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
B: 第8行： p=(int *)(n*malloc(sizeof(int*)))第12行： *p+i=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
C: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *p+i=i*10第16行： printf(“array[i]=%dn”,i,*p+i)
D: 第8行： p=(int)malloc(n*sizeof(int *));第12行： *(p+i)=i*10第16行： printf(“array[i]=%dn”,i,*(p+i))
答案: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
2、单选题：
下列说法正确的是
A: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。
B: 函数free()的参数是指向被释放的动态内存的指针变量。
C: 对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
D: 函数free的函数原型是void* free(void* p);表示函数没有返回值。
E: 程序运行结束以后，所有内存自然会随之马上释放并归还给系统，因此即使不释放不再使用的动态内存，也不会有什么问题。
F: 执行函数调用时，系统在堆上为函数内的局部变量及形参分配内存，函数执行结束时，需要程序员用free()函数释放这些内存。
G: 用动态内存分配函数来申请的内存都是从栈上分配的。
H: 栈的特点是先进先出。
I: 用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。
答案: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。;
函数free()的参数是指向被释放的动态内存的指针变量。;
对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
3、单选题：
申请一个具有n个int型元素的一维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(n * sizeof(int));
B: p = (int *)calloc(n, sizeof(int));
C: p = (int *) malloc(n, sizeof(int));
D: p = (int *)calloc(n * sizeof(int));
E: int p[n];
F: p = (int *) realloc(n * sizeof(int));
答案: p = (int *) malloc(n * sizeof(int)); ;
p = (int *)calloc(n, sizeof(int));
4、单选题：
假设用下面语句申请了一块动态内存，并用指针变量指p向了它，用这块内存保存m*n个整型元素，即作为一个二维动态数组来使用，那么下面哪种通过p访问这个二维动态数组第i行第j列元素的方法是正确的（）。p = (int *) malloc(m*n*sizeof(int));或者p = (int *) calloc(m*n, sizeof(int));
A: p[i*n+j]
B: *（p+i*n+j）
C: p[j*n+i]
D: p[i][j]
E: *p[i*n+j]
F: p+i*n
G: p+i*n+j
答案: p[i*n+j];
*（p+i*n+j）
5、单选题：
下列说法错误的是
A: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。
B: 用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。
C: 在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
D: 对于用动态内存分配函数申请的内存，如果在使用结束后不释放的话，会发生内存泄漏。
E: 对于用动态内存分配函数申请的内存，如果在释放以后还继续使用的话，那么会产生非法内存访问的错误。
F: 用free释放指针指向的内存以后，仍然继续访问指针所指向的内存，将导致产生悬空指针，也称为野指针。
G: 计算动态分配内存的字节数的时候，应该始终使用sizeof运算符，因为某些类型在不同的系统下所占内存空间的字节数是不同的。
H: 为了避免内存分配不成功就使用它，应该在使用内存前检查指针是否为空指针。
答案: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。;
用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。;
在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
6、单选题：
下列说法错误的是
A: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
B: 函数realloc()用于改变原来分配的存储空间的大小。
C: 对于函数void * calloc(unsigned int num, unsigned int size)而言,成功调用该函数就相当于声明了一个一维数组，参数num决定了数组的长度即元素个数，参数size确定了每个数组元素的所占内存空间的字节数。
D: 向系统动态申请的内存使用结束后，应使用free()函数进行内存释放。
E: 函数void * calloc(unsigned int num, unsigned int size)的功能是向系统申请num个size大小的连续内存块，并初始化为0
F: void*型指针不指定其指向哪一种类型，可指向任意类型的变量，是一种generic或typeless类型的指针，使用时需强转(Type*)为其他类型。
G: 用calloc动态申请的内存会自动初始化为0.
答案: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
7、单选题：
下面关于内存泄漏问题的描述错误的是（）
A: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。
B: 内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。
C: 指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
D: 出现内存泄露并不是一定会导致系统发生异常，因为实际中内存耗尽的情况非常罕见，内存泄露问题的严重程度取决于每次函数调用时遗留内存垃圾的多少和函数被调用的次数。
E: 内存泄漏问题通常需要运行相当一段时间后才能发现。
F: C语言没有提供内存垃圾回收机制，因此需要程序调用free函数来释放不再需要的动态内存。
G: 需长期稳定运行的服务程序，以及需要频繁对内存操作且消耗空间较大的程序，通常对内存泄漏比较敏感。
答案: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。;
内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。;
指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
8、单选题：
关于下面程序中的变量和常量分布的内存区域说法错误的是#include <stdio.h>
#include <stdlib.h >
static char array2[] = {“dddd”};
char array3[100];
int main()
{
short b;
char array1[]=”aaaa”;
char *p;
p = (char *)malloc(10*sizeof(int));
strcpy(p,”bbbb”);
free(p);
return 0;
}
A: 指针变量p存放在堆中
B: “bbbb”存放在栈中
C: array3数组存放在静态存储区
D: 本题中指针变量p指向的内存空间在堆中
E: “bbbb”存放在常量区
F: array2存放在静态存储区
答案: 指针变量p存放在堆中;
“bbbb”存放在栈中
9、单选题：
对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是
A: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
B: void *的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
C: void *的含义是指该函数没有返回值
D: 以上说法都不对
答案: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
10、单选题：
下面说法错误的是
A: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
B: 如果希望在程序的运行期间改变数组的长度，则需要使用动态内存分配函数实现动态数组。
C: 动态内存分配是指在程序运行时为变量分配内存的一种方法。
D: 栈和堆都属于动态存储区。
答案: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
11、单选题：
下面程序希望得到的运行结果如下：Total string numbers = 3How are you目前程序存在错误，请找出错误所在并加以改正。#include <stdio.h>
void Print(char *arr[], int len);
int main()
{
char *pArray[] = {“How”,”are”,”you”};
int num = sizeof(pArray) / sizeof(char);
printf(“Total string numbers = %dn”, num);
Print(pArray, num);
return 0;
}
void Print(char *arr[], int len)
{
int i;
for (i=0; i<len; i++)
{
printf(“%s “, arr[i]);
}
printf(“n”);
}
A: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
B: 第6行错误改正为：int num = sizeof(char*) / sizeof(pArray);
C: 第12行错误改正为：char arr[]
D: 第5行错误改正为：char *pArray = {“How”,”are”,”you”}
答案: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
12、单选题：
申请一个m行n列的整型的二维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(m*n*sizeof(int));
B: p = (int *)calloc(m*n, sizeof(int));
C: p = (int *) malloc(m*n, sizeof(int));
D: p = (int *)calloc(m * n * sizeof(int));
E: int p[m][n];
F: p = (int *) realloc(m * n * sizeof(int));
答案: p = (int *) malloc(m*n*sizeof(int)); ;
p = (int *)calloc(m*n, sizeof(int));
练兵区——单选题——不计入总分
1、单选题：
假设用下面语句申请了一块动态内存，并用指针变量指p向了它，用这块内存保存m*n个整型元素，即作为一个二维动态数组来使用，那么下面哪种通过p访问这个二维动态数组第i行第j列元素的方法是正确的（）。p = (int *) malloc(m*n*sizeof(int));或者p = (int *) calloc(m*n, sizeof(int));
A: p[i*n+j]
B: *（p+i*n+j）
C: p[j*n+i]
D: p[i][j]
E: *p[i*n+j]
F: p+i*n
G: p+i*n+j
答案: p[i*n+j];
*（p+i*n+j）
2、单选题：
下面程序的功能是通过动态分配内存函数malloc产生动态数组，程序的某次运行结果如下：Enter array size:8↙array[0]=0array[1]=10array[2]=20array[3]=30array[4]=40array[5]=50array[6]=60array[7]=70按要求在空白处填写适当的表达式或语句，使程序完整并符合题目要求。#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p,n,i;
printf(“Enter array size:”);
scanf(“%d”,&n);
__________________;
for(i=0;i<n;i++)
{
____________;
}
for(i=0;i<n;i++)
{
_______________;
}
free(p);
return 0;
}
A: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
B: 第8行： p=(int *)(n*malloc(sizeof(int*)))第12行： *p+i=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
C: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *p+i=i*10第16行： printf(“array[i]=%dn”,i,*p+i)
D: 第8行： p=(int)malloc(n*sizeof(int *));第12行： *(p+i)=i*10第16行： printf(“array[i]=%dn”,i,*(p+i))
答案: 第8行： p=(int *)malloc(n*sizeof(int));第12行： *(p+i)=i*10第16行： printf(“array[%d]=%dn”,i,*(p+i))
3、单选题：
下列说法正确的是
A: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。
B: 函数free()的参数是指向被释放的动态内存的指针变量。
C: 对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
D: 函数free的函数原型是void* free(void* p);表示函数没有返回值。
E: 程序运行结束以后，所有内存自然会随之马上释放并归还给系统，因此即使不释放不再使用的动态内存，也不会有什么问题。
F: 执行函数调用时，系统在堆上为函数内的局部变量及形参分配内存，函数执行结束时，需要程序员用free()函数释放这些内存。
G: 用动态内存分配函数来申请的内存都是从栈上分配的。
H: 栈的特点是先进先出。
I: 用free释放指针变量所指向的内存以后，就意味着该指针变量变成了空指针。
答案: 执行函数调用时，系统自动在栈上为函数内的局部变量及形参分配内存，函数执行结束时，自动释放这些内存，这些无需程序员来管理。;
函数free()的参数是指向被释放的动态内存的指针变量。;
对于用动态内存分配函数申请的内存，其生存期由程序员自己来决定。
4、单选题：
对于函数void * malloc(unsigned int size)而言，下面的说法中正确的是
A: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
B: void *的含义是指函数调用的返回值为指针类型，该指针为空指针，其值为NULL。
C: void *的含义是指该函数没有返回值
D: 以上说法都不对
答案: void *的含义是指该指针基类型未知，若将函数调用的返回值赋值给某个指针，必须做强制类型转换，将返回的指针值转换为所需的类型。
5、单选题：
下列说法错误的是
A: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。
B: 用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。
C: 在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
D: 对于用动态内存分配函数申请的内存，如果在使用结束后不释放的话，会发生内存泄漏。
E: 对于用动态内存分配函数申请的内存，如果在释放以后还继续使用的话，那么会产生非法内存访问的错误。
F: 用free释放指针指向的内存以后，仍然继续访问指针所指向的内存，将导致产生悬空指针，也称为野指针。
G: 计算动态分配内存的字节数的时候，应该始终使用sizeof运算符，因为某些类型在不同的系统下所占内存空间的字节数是不同的。
H: 为了避免内存分配不成功就使用它，应该在使用内存前检查指针是否为空指针。
答案: 无论是在栈上还是在堆上分配的内存都需要程序员用free来释放。;
用return语句既可以从函数返回调用动态内存分配函数动态申请的内存的地址，也可以从函数返回在函数内定义的局部变量的地址。;
在动态分配一块内存后，接下来又丢失了对这块内存的追踪路径，这种错误属于悬空指针即野指针。
6、单选题：
下列说法错误的是
A: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
B: 函数realloc()用于改变原来分配的存储空间的大小。
C: 对于函数void * calloc(unsigned int num, unsigned int size)而言,成功调用该函数就相当于声明了一个一维数组，参数num决定了数组的长度即元素个数，参数size确定了每个数组元素的所占内存空间的字节数。
D: 向系统动态申请的内存使用结束后，应使用free()函数进行内存释放。
E: 函数void * calloc(unsigned int num, unsigned int size)的功能是向系统申请num个size大小的连续内存块，并初始化为0
F: void*型指针不指定其指向哪一种类型，可指向任意类型的变量，是一种generic或typeless类型的指针，使用时需强转(Type*)为其他类型。
G: 用calloc动态申请的内存会自动初始化为0.
答案: 系统对使用动态内存分配函数malloc()申请的存储空间自动初始化为0.
7、单选题：
下面关于内存泄漏问题的描述错误的是（）
A: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。
B: 内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。
C: 指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
D: 出现内存泄露并不是一定会导致系统发生异常，因为实际中内存耗尽的情况非常罕见，内存泄露问题的严重程度取决于每次函数调用时遗留内存垃圾的多少和函数被调用的次数。
E: 内存泄漏问题通常需要运行相当一段时间后才能发现。
F: C语言没有提供内存垃圾回收机制，因此需要程序调用free函数来释放不再需要的动态内存。
G: 需长期稳定运行的服务程序，以及需要频繁对内存操作且消耗空间较大的程序，通常对内存泄漏比较敏感。
答案: 只要程序中使用的malloc和free的数量是配对的，那么就不会出现内存泄漏问题。;
内存泄漏属于非法内存访问错误，就是代码访问了不该访问的内存。;
指针变量所占的内存被释放了，也就意味着它所指向的动态内存也会被自动释放。
8、单选题：
下面程序希望得到的运行结果如下：Total string numbers = 3How are you目前程序存在错误，请找出错误所在并加以改正。#include <stdio.h>
void Print(char *arr[], int len);
int main()
{
char *pArray[] = {“How”,”are”,”you”};
int num = sizeof(pArray) / sizeof(char);
printf(“Total string numbers = %dn”, num);
Print(pArray, num);
return 0;
}
void Print(char *arr[], int len)
{
int i;
for (i=0; i<len; i++)
{
printf(“%s “, arr[i]);
}
printf(“n”);
}
A: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
B: 第6行错误改正为：int num = sizeof(char*) / sizeof(pArray);
C: 第12行错误改正为：char arr[]
D: 第5行错误改正为：char *pArray = {“How”,”are”,”you”}
答案: 第6行错误改正为：int num = sizeof(pArray) / sizeof(char*);
9、单选题：
申请一个具有n个int型元素的一维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(n * sizeof(int));
B: p = (int *)calloc(n, sizeof(int));
C: p = (int *) malloc(n, sizeof(int));
D: p = (int *)calloc(n * sizeof(int));
E: int p[n];
F: p = (int *) realloc(n * sizeof(int));
答案: p = (int *) malloc(n * sizeof(int)); ;
p = (int *)calloc(n, sizeof(int));
10、单选题：
关于下面程序中的变量和常量分布的内存区域说法错误的是#include <stdio.h>
#include <stdlib.h >
static char array2[] = {“dddd”};
char array3[100];
int main()
{
short b;
char array1[]=”aaaa”;
char *p;
p = (char *)malloc(10*sizeof(int));
strcpy(p,”bbbb”);
free(p);
return 0;
}
A: 指针变量p存放在堆中
B: “bbbb”存放在栈中
C: array3数组存放在静态存储区
D: 本题中指针变量p指向的内存空间在堆中
E: “bbbb”存放在常量区
F: array2存放在静态存储区
答案: 指针变量p存放在堆中;
“bbbb”存放在栈中
11、单选题：
下面说法错误的是
A: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
B: 如果希望在程序的运行期间改变数组的长度，则需要使用动态内存分配函数实现动态数组。
C: 动态内存分配是指在程序运行时为变量分配内存的一种方法。
D: 栈和堆都属于动态存储区。
答案: 调用malloc函数后将会返回一个指针类型的地址，该值可以直接赋值给特定的指针变量，无需强制类型转换。
12、单选题：
申请一个m行n列的整型的二维动态数组，可以使用下面的哪条语句？
A: p = (int *) malloc(m*n*sizeof(int));
B: p = (int *)calloc(m*n, sizeof(int));
C: p = (int *) malloc(m*n, sizeof(int));
D: p = (int *)calloc(m * n * sizeof(int));
E: int p[m][n];
F: p = (int *) realloc(m * n * sizeof(int));
答案: p = (int *) malloc(m*n*sizeof(int)); ;
p = (int *)calloc(m*n, sizeof(int));
第2周——全面复习阶段模拟题作业及解析周而复始的循环之道
嵌套循环
1、单选题：
下列说法错误的是（ ）。
A: 执行嵌套循环时是先执行内层循环，后执行外层循环。
B: 嵌套循环的内层和外层循环的循环控制变量不能同名。
C: 嵌套循环的循环次数等于外层循环的循环次数与内层循环的循环次数之积。
D: 如果一个循环的循环体中又完整地包含了另一个循环，则称为嵌套循环。
答案: 执行嵌套循环时是先执行内层循环，后执行外层循环。
流程的转移控制
1、单选题：
下面程序段中的break语句是转移到哪里去执行（）。for(…)
{
for(…)
{
switch(…)
{
case 1: …
break;
case 2:…
…
}
A: //code
}
B: //code
}
C: //code
A: 转到标号A所在的语句行与执行
B: 转到标号B所在的语句行与执行
C: 转到标号C所在的语句行与执行
D: 不进行流程转移，而是继续执行break后面的语句
答案: 转到标号A所在的语句行与执行
程序调试
1、单选题：
下列说法错误的是（）。
A: 程序测试的目的就是验证程序的正确性。
B: 程序中常见的错误有三种：编译错误，链接错误，以及运行时错误。
C: 编译错误通常是由语法错误造成的。
D: 运行时错误是指在程序运行时发生的错误，运行时错误有两种：一种是导致程序的运行结果与预期的不一致，另一种是导致程序无法正常运行。
答案: 程序测试的目的就是验证程序的正确性。
逗号运算符
1、单选题：
下列说法错误的是（）。
A: 逗号运算符也称为顺序求值运算符，由逗号运算符构成的表达式称为逗号表达式。
B: 多数情况下，我们并不使用整个逗号表达式的值，主要用它来顺序求得到各个子表达式的值。
C: 逗号表达式主要用在循环语句中同时对多个变量赋初值等。
D: 在逗号表达式中，其第一个表达式的值就是整个逗号表达式的值。
答案: 在逗号表达式中，其第一个表达式的值就是整个逗号表达式的值。
随机数的生成
1、单选题：
下列说法错误的是（）。
A: 函数rand()用于生成一个[0,RAND_MAX]间的随机数，RAND_MAX是不大于双字节整数的最大值32767的宏常量。使用函数rand()必须在程序开头加上这样一条编译预处理指令：#include <stdio.h>
B: magic = rand()%100 + 1用于生成[1，100]之间的随机数。
C: 事实上，函数rand()产生的都是伪随机数。
D: 函数srand()用于为rand()设置随机数种子，使rand()产生的随机数“随机化”。
答案: 函数rand()用于生成一个[0,RAND_MAX]间的随机数，RAND_MAX是不大于双字节整数的最大值32767的宏常量。使用函数rand()必须在程序开头加上这样一条编译预处理指令：#include <stdio.h>
第10周——字符串C语言世界中的大力水手
从函数返回字符串
1、判断题：
函数返回值的类型既可以是字符指针，也可以是字符数组。
A: 正确
B: 错误
答案: 错误
向函数传递字符串
1、判断题：
向函数传递字符串，既可以用字符数组做函数参数，也可以用字符指针做函数参数，这两种方式都是传引用调用，就是将字符串的首地址、而非字符串中的全部字符传给形参。
A: 正确
B: 错误
答案: 正确
字符串处理函数
1、单选题：
下列说法正确的是（）。
A: strlen()计算的是包含”在内的字符串的长度。
B: 字符串不能使用赋值运算符整体复制，必须使用strcpy函数进行字符串的复制。strcpy(str2, str1);是将字符数组str2中的字符串复制到字符数组str1中。
C: strcat(str2, str1);是将字符数组str2中的字符串连接到字符数组str1中的字符串的末尾，str1中的字符串末尾的空字符”将被覆盖。
D: 字符串不能用关系运算符>,<,==直接比较大小，必须使用strcmp函数比较大小，当出现第一对不相等的字符时，就由这两个字符的ASCII码值的大小来决定其所在字符串的大小。
答案: 字符串不能用关系运算符>,<,==直接比较大小，必须使用strcmp函数比较大小，当出现第一对不相等的字符时，就由这两个字符的ASCII码值的大小来决定其所在字符串的大小。
字符串的表示与存储
1、单选题：
下列说法正确的是（）。
A: 用双引号括起的一串字符是字符串常量，系统自动为其添加空字符”作为字符串的结束标志。
B: 字符数组的最后一个元素必须是字符’0’才能表示一个字符串。
C: char *pStr = “Hello China”;表示定义了一个指向字符串常量的字符指针变量。此时既可以修改pStr的值，也可以通过间接寻址的方法修改pStr指向的字符。
D: char *pStr;scanf(“%s”, pStr);这两条语句的作用就是将用户从键盘输入的字符串保存到字符指针变量pStr中。
答案: 用双引号括起的一串字符是字符串常量，系统自动为其添加空字符”作为字符串的结束标志。
第11周——指针的孪生兄弟
元素在二维数组中相对于首地址的偏移量
1、单选题：
二维数组a有m行n列，则在a[i][j]之前的元素个数为（）
A: j*n+i
B: i*n+j
C: i*n+j-1
D: i*n+j+1
答案: i*n+j
字符指针数组
1、判断题：
char *country[] = {“America”, “England”, “Australia”, “China”, “Finland”};这条语句定义了一个字符指针数组country，并用初始化列表中的每个字符串的首地址为字符指针数组country的元素进行初始化，并不是将初始化列表中的字符串保存到字符指针数组中。
A: 正确
B: 错误
答案: 正确
指针和一维数组
1、判断题：
当指针变量指向一维数组的时候，sizeof(数组名）和sizeof(指针变量名）的计算结果是相同的。
A: 正确
B: 错误
答案: 错误
指针的算术运算
1、单选题：
下列说法错误的是（）。
A: 指针指向数组元素时，指针算术运算才有意义
B: 两个指针指向同一个数组时，指针相减才有意义
C: 指针的算术运算允许通过对指针变量重复自增来访问数组的元素
D: p++就是将指针变量p加上一个字节
答案: p++就是将指针变量p加上一个字节
第12周——海陆空齐上阵又来了一堆数据
共用体类型
1、单选题：
下列说法错误的是（）。
A: 编译器只为共用体中最大的成员分配足够的内存空间。共用体的成员在这个空间内是彼此覆盖的，都从同一起始地址开始存储。
B: 与结构体不同的是，共用体在内存中所占空间的字节数取决于占空间最多的那个成员变量。
C: 共用体变量在每一瞬时只能保存一个成员，起作用的成员是最后一次赋值的成员。
D: 共用体和结构体的成员访问方式以及成员的初始化方式都是一样的，都使用成员选择运算符访问成员变量，都可以在定义的时候对所有成员进行初始化。
答案: 共用体和结构体的成员访问方式以及成员的初始化方式都是一样的，都使用成员选择运算符访问成员变量，都可以在定义的时候对所有成员进行初始化。
关键字typedef
1、判断题：
关键字typedef主要用于定义一种新的数据类型。
A: 正确
B: 错误
答案: 错误
向函数传递结构体
1、单选题：
下列说法错误的是（）。
A: 用结构体变量做函数参数，是将整个结构体的所有成员的内容传给被调函数，因此在被调函数中对结构体内容的修改不影响原结构体变量。
B: 用结构体数组/结构体指针作函数参数的参数传递效率比用结构体变量做函数参数的参数传递效率要高。
C: 用结构体数组/结构体指针作函数参数，是复制结构体的首地址给被调函数，因此在被调函数中可以修改结构体指针所指向的结构体的内容。
D: 数组和结构体变量都不可以用做函数返回值的类型。
答案: 数组和结构体变量都不可以用做函数返回值的类型。
对结构体的操作
1、单选题：
下列说法错误的是（）。
A: 对结构体变量的成员的访问是通过名字并使用成员选择运算符来访问的。
B: 只能在相同类型的结构体变量之间进行赋值。
C: 可以使用==和!=来判定两个结构体相等或不等。
D: 对嵌套的结构体成员，必须以级联的方式来访问。
答案: 可以使用==和!=来判定两个结构体相等或不等。
枚举类型
1、单选题：
下列对枚举类型的使用的代码中错误的是（）。
A: enum {no, yes, none}answer;
if (answer == yes)
{
printf(“Yesn”);
}
B: enum response{no = -1, yes = 1, none = 0};
enum response answer;
C: answer = yes;
printf(“%d”, answer);
D: answer = “yes”;
printf(“%s”, answer);
答案: answer = “yes”;
printf(“%s”, answer);
2、判断题：
和整型、实型、字符型一样，枚举类型也是一种基本数据类型。
A: 正确
B: 错误
答案: 正确
结构体变量的定义
1、单选题：
下面哪条语句是正确的。
A: typedef struct student
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
}STUDENT;
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
B: typedef struct STUDENT
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
};
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
C: struct
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
};
struct stu1;
D: struct student{ long studentID; char studentName[10]; char studentSex; int yearOfBirth; int score[4]; }STUDENT;STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
答案: typedef struct student
{
long studentID;
char studentName[10];
char studentSex;
int yearOfBirth;
int score[4];
}STUDENT;
STUDENT stu1 = {100310121, “王刚”, ‘M’, 1991, {72,83,90,82}};
结构体变量的访问
1、单选题：
已知：typedef struct date
{
int year;
int month;
int day;
}DATE;
typedef struct student
{
long studentID;
char studentName[10];
char studentSex;
DATE birthday;
int score[4];
}STUDENT;
STUDENT stu1;
STUDENT *pt = &stu1;则下列访问结构体变量的方法中，哪个是错误的。
A: stu1. birthday. year = 1999;
B: (*pt). birthday. year = 1999;
C: pt -> birthday -> year = 1999;
D: pt -> birthday. year = 1999;
答案: pt -> birthday -> year = 1999;
结构体的嵌套
1、判断题：
在一个结构体内可以包含另一个不同类型的结构体作为其成员。
A: 正确
B: 错误
答案: 正确
结构体类型所占内存的字节数
1、单选题：
下列说法错误的是（）。
A: 结构体类型所占内存的字节数就是结构体的每个成员类型所占内存字节数的总和。
B: 结构体在内存中所占的字节数不仅与所定义的结构体类型有关，还与计算机系统本身有关。
C: 计算结构体所占内存的字节数时，一定要使用sizeof运算符。
D: 内存对齐的主要目的就是为了提高内存的寻址效率。不同的系统和编译器，内存对齐方式可能会不同，是机器相关的。
答案: 结构体类型所占内存的字节数就是结构体的每个成员类型所占内存字节数的总和。
第14周——结构设计的艺术
第14周测验
1、单选题：
关于图的说法正确的是
A: 图由顶点和边构成
B: 图的邻接表属于顺序存储方式
C: 图的邻接表属于链式存储方式
D: 图的邻接矩阵中存储的是图的顶点
答案: 图由顶点和边构成
2、单选题：
已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点
且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p, *pr, *head;
若要找到p的前驱结点并将地址保存在pr中，则下面正确的语句序列是
A: pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
B: p = head;
pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
C: pr = head;
while(pr!=p)
{
pr = pr->next;
}
D: p = head;
while(p->next!=pr)
{
p = p->next;
}
答案: pr = head;
while(pr->next!=p)
{
pr = pr->next;
}
3、单选题：
关于队列的说法正确的是
A: 队列和栈都属于线性结构
B: 队列存储在数组a中，队首为a[front],队尾为a[rear],则队列为空的条件是rear == front
C: 一个队列的入队顺序是a,b,c,d,则出队顺序应该是d,c,b,a
D: 队列具有先进后出的特点
答案: 队列和栈都属于线性结构
4、单选题：
若已建立下面的链表结构，指针p、q分别指向图中所示结点，则不能将q所指的结点插入到链表末尾的一组语句是
A: p = p->next; q->next = p; p->next = q;
B: q->next = NULL; p = p->next; p->next = q;
C: p = p->next; q->next = p->next; p->next = q;
D: p = (*p).next; (*q).next = (*p).next; (*p).next = q;
答案: p = p->next; q->next = p; p->next = q;
5、单选题：
下列叙述中正确的是
A: 作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。
B: 对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
C: 线性链表的长度是固定的，在访问之前就已经确定下来。
D: 构成线性链表的存储单元是连续的，如结点P与它的前驱结点及后继结点之间就是连续的。
E: 线性链表的数据域一般只包含一个成员数据，如data。
F: 作为线性单向链表的尾结点，其指针域的值设为空指针void，表示链表的结束。
答案: 作为线性单向链表的尾结点，其指针域的值设为空指针NULL，表示链表的结束。;
对于单向链表而言，一旦链表中某个结点的指针域数据丢失，将会导致无法找到下一个结点，进而丢失该节点后面的所有结点数据。
6、单选题：
下面属于动态数据结构的是
A: 链表
B: 栈
C: 结构体数组
D: 指针数组
E: 字符数组
答案: 链表;
栈
7、单选题：
关于树的说法错误的是
A: 树至少有一个结点
B: 树必须有根结点
C: 树是一种非线性结构
D: 树的结点之间是一对多的关系
E: 二叉树的左右子树不能交换
答案: 树至少有一个结点;
树必须有根结点
8、单选题：
以下程序执行后的输出结果是#include <stdio.h>
#include <stdlib.h>
struct NODE
{
int num;
struct NODE *next;
};
int main( )
{
struct NODE *p,*q,*r;
int sum=0;
p=(struct NODE *)malloc(sizeof(struct NODE));
q=(struct NODE *)malloc(sizeof(struct NODE));
r=(struct NODE *)malloc(sizeof(struct NODE));
p->num=1;
q->num=2;
r->num=3;
p->next=q;
q->next=r;
r->next=NULL;
sum+=q->next->num;
sum+=p->num;
printf(“%dn”,sum);
return 0;
}
A: 4
B: 3
C: 5
D: 6
答案: 4
9、单选题：
向建立好的单向链表中的结点pr后插入一个新结点p，且所有结点都已具有如下形式的结构定义：struct node{ int data; struct node *next;}*p, *pr, *head;则操作正确的是
A: p->next = pr->next;pr->next = p;
B: struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
C: pr->next = p;
D: p->next = pr->next;pr = p;
E: pr->next = p;p->next = pr->next;
答案: p->next = pr->next;pr->next = p;;
struct node * pTemp;pTemp = pr->next;pr->next = p;p->next = pTemp;
10、单选题：
关于单向链表说法错误的是
A: 单向链表在内存中是连续存储的
B: 结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针
C: 存储空间可以动态的获取和释放
D: 与数据相比，单向链表适合反复进行删除、插入操作
答案: 单向链表在内存中是连续存储的
11、单选题：
已知head是非空单链表的头指针，p结点既不是头结点，也不是尾结点，q是尾结点的前驱结点。
且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p，*q;
则下面语句序列的功能是
while(p->next->next != NULL)
{
p = p->next;
}
free(p->next);
p->next = NULL;
A: 删除链表的尾结点
B: 删除p结点
C: 删除结点q
D: 删除p的前驱结点
答案: 删除链表的尾结点
12、单选题：
有以下结构体说明和变量定义，如图所示，指针p、q、r分别指向一个链表中的三个连续结点。现要将q和r所指结点的先后位置交换，同时要保持链表的连续，以下错误的程序段是
struct node
{
int data;
struct node *next;
}*p, *q, *r;
A: r->next=q; q->next=r->next; p->next=r;
B: q->next=r->next; p->next=r; r->next=q;
C: p->next=r; q->next=r->next; r->next=q;
D: q->next=r->next; r->next=q; p->next=r;
答案: r->next=q; q->next=r->next; p->next=r;
13、单选题：
已知L是非空单链表，head是链表的头指针，且所有结点都已具有如下形式的结构定义：
struct node
{
int data;
struct node *next;
}*p;
若要删除头结点，则下面正确的语句序列是
A: p = head;head = p->next;free(p);
B: head = head->next;free(head);
C: p = head->next;free(p);
D: head
上方为免费预览版答案，如需购买完整答案，请点击下方红字：
为了方便下次阅读，建议在浏览器添加书签收藏本网页
添加书签方法：
1.电脑按键盘的Ctrl键+D键即可收藏本网页
2.手机浏览器可以添加书签收藏本网页
点击浏览器底部菜单-【添加书签】-收藏本网页
点击浏览器底部菜单-【书签/历史】-可查看本网页
获取更多慕课答案，欢迎在浏览器访问我们的网站：
http://mooc.mengmianren.com
注：请切换至英文输入法输入域名，如果没有成功进入网站，请输入完整域名：http://mooc.mengmianren.com/
我们的公众号
打开手机微信，扫一扫下方二维码，关注微信公众号：萌面人APP
本公众号可查看各种网课答案，还可免费查看大学教材答案
点击这里，可查看公众号功能介绍
APP下载
APP功能说明
1.可查看各种网课答案
点击【萌面人官网】，可查看知到智慧树，超星尔雅学习通，学堂在线等网课答案
点击【中国大学慕课答案】，可查看mooc慕课答案
2.可一键领取淘宝/天猫/京东/拼多多无门槛优惠券
如图所示，点击对应图标即可领取淘宝/天猫/京东/拼多多无门槛优惠券
汤屏补羞病筋遁梅柬扣林卢蒙