C语言易错选择判断题

绝地灬酷狼 2023-10-08 06:29 10阅读 0赞

**选择题：**  
1.设有如下定义：  
struct sk  
\{int a; float b;\} data, \*p;  
若有p=&data，则对data中的成员a的正确引用是（ B ）。  
A: (\*p).data.a　  
B: (\*p).a  
C: p->data.a　  
D: p.data.a  
【解析】本题主要考查结构指针：p=&data，访问结构体的成员。它可以通过结构变量访问，即data可以用等价的指针形式：(\*p)．a和P一>a来访问结构体变量中的成员。  
2.若有说明：long \*p, a; 则不能通过scanf语句正确给输入项读入数据的程序段是（ A ）。  
A: \*p=&a; scanf(“%ld”,p);  
B: p=(long \*)malloc(8); scanf(“%ld”,p);  
C: scanf(“%ld”,p=&a);  
D: scanf(“%ld”,&a);  
【解析】\*p应该指向long型的变量,而&a是一个变量的地址,所以错了,如果将式子改为p=&a就对了,  
3.当定义一个结构体变量时系统分配给它的内存是：***B***  
A: 各成员所需内存量的总和  
B: 成员中占内存量最大者所需的容量的倍数  
C: 结构中第一个成员所需内存量  
D: 结构中最后一个成员所需内存量  
【解析】书上定义  
4.若有以下定义和赋值语句，则对b数组的第i行第j列（假设i，j已正确说明并赋值）元素的非法引用为\_\_\_\_\_\_C\_\_\_\_\_\_\_\_。  
int b\[2\]\[3\]=\{0\}, (\*p)\[3\];  
p=b;  
A: *(*(p+i)+j)  
B: *(p\[i\]+j)  
C: (p+i)+j  
D: ((p+i))\[j\]  
【解析】因为 a 是地址的地址（或者说指针的指针）,所以必须用到两次 \* 才可以.  
(a+i) 相当于 a\[i\],(*(a+i)+j) 就相当于 a\[i\]\[j\].  
5.若希望当A的值为奇数时，表达式的值为”真”，A的值为偶数时，表达式的值为”假”，则以下不能满足要求的表达式是（ C ）。  
A: A%21　  
B: !(A%20)  
C: !(A%2)  
D: A%2  
【解析】表示等价,两侧表达式相等返回1,不等返回0.就上题而言(A%2)与(A%21)返回值是相同的,而与(A%20)返回值相反.  
6.有一堆零件（100到200之间），如果分成4个零件一组的若干组，则多2个零件；若分成7个零件一组，则多3个零件；若分成9个零件一组，则多5个零件。下面程序是求这堆零件总数，请选择填空（ D ）。  
\#include <stdio.h>  
main()  
\{int i;  
for(i=100;i<200;i++)  
if((i-2)%40)  
if(!((i-3)%7))  
if( \_\_\_\_\_\_ )  
printf("%d",i);  
\}  
A: i%9=5  
B: i%9!=5  
C: (i-5)%9!=0  
D: i%9==5  
【解析】循环  
7.下面程序段的运行结果是\_\_\_\_\_\_A\_\_\_\_\_\_\_。  
char s\[6\]; s=“abcd”; printf(""%s"\\n",s);  
A: “abcd”  
B: “abcd "  
C: “abcd”  
D: 编译出错  
【解析】 char s\[6\]; s=“abcd”;printf(”"%s"\\n",s);本身 程序就错误 应该为 char s\[6\]; \*s=“abcd”;  
printf(""%s"\\n",s); 因为 指针s不能和"abcd"划等号而且printf(""%s"\\n",s);多出了一个"肯定不行  
8.以下说法中正确的是（ D ）。  
A: \#define和printf都是C语句  
B: \#define是C语句，而printf不是  
C: printf是C语句，但\#define不是  
D: \#define和printf都不是C语句  
【解析】可以肯定的是\#define和printf都是不是C语言的控制语句,C语言只有九种控制语句  
printf是一个C标准库函数,函数原型定义在stdio.h.从严格意义上来说,库函数不属于C语言.  
\#define只是一个预处理命令,用来做替换,在编译的时候被展开罢了.  
9.执行语句for(i=1;i++<4;) ;后变量i的值是（ C ）。  
A: 3  
B: 4  
C: 5  
D: 不定  
【解析】当i=4时,会进行条件判断i<4吗?不小于,因此就不执行循环体了,但是记住,现在判断条件是i++<4,也就是说先判断后自增,那么自增一下,i就是5了, 这与++i<4明显不同,++i<4是先自增,然后i的值变为4,之后就退出循环了,因此后者(++i<4)运行次数要比前者(i++<4) 少运行一次  
10.下面不能正确进行字符串赋值操作的是( B )。  
A: char s\[6\]=\{“ABCDE”\};  
B: char s\[5\]=\{‘A’,'B’,'C’,'D’,'E’\};  
C: char \*s;s=”ABCDE”;  
D: char \*s; scanf(“%s”,s);  
【解析】A. char s［5］=\{“ABCDE”\}; “ABCDE"占用空间是6字节，超出s的长度了  
B. char s［5］=\{ ′A′, ′B′, ′C′, ′D′, ′E′\}; 没有字符串结束的终结符，s不能当字符串使用  
C. char *s;s=“ABCDE”; 正确  
D. char s;char a; scanf（"%s",&s）; s还是个野指针  
11.若有赋值语句p=（double）malloc(10*sizeof(double));,则正确的定义语句是（ A）  
A: double \*p  
B: float \*\*p  
C: double \*\*p  
D: float \*p  
【解析】\*p 是(double \*)的,p自然是 double \*\*p的 不用考虑其他的  
12.若int (\*p)\[5\];，其中，p是\_\_\_C\_\_\_\_。  
A: 5个指向整型变量的指针  
B: 指向5个整型变量的函数指针  
C: 一个指向具有5个整型元素的一维数组的指针  
D: 具有5个指针元素的一维指针数组，每个元素都只能指向整型量  
13.main函数的正确说明形式是\_\_\_\_\_B\_\_\_\_\_\_。  
A: main(int argc,char \*argv)  
B: main(int abc,char \*\*abv)  
C: main(int argc,char argv)  
D: main(int c,char v\[\])  
【解析】三种：  
int main(int argc,char \*argv\[\])  
int main(int argc,char \*\[\] argv)  
int main(int argc,char \*\* argv)

argc 代表参数的个数，包括程序名称。 argv是一个字符串数组，代表参数  
14.若要建立如下关系，错误的语句组是( A )。  
![在这里插入图片描述][20191229144823878.jpg]  
A: int *p=&x, x;p=10;  
B: int x,* p=&x; \*p=10;  
C: int \*p, x=10; p=&x;  
D: int \*p, x;p=&x ; x=10;  
【解析】在变量类型说明语句中 \*表示变量是指针变量，在其他语句中，\*称为指针运算，用于访问指针所指向的对象的值，&称为取地址运算，用来得到一个对象的地址。故B、C、D都是正确的，不能选择。A中指针变量p取不到x地址，因为x还没有定义，所以选择A。;  
15.已定义以下函数：

int  fun(int  *p){return  *p;}
    
      fun函数返回值是 (  C )

A: 一个整数  
B: 形参p的地址值  
C: 形参p中存放的值  
D: 不确定的值  
【解析】已知：int a\[5\]=\{1,2,3,4,5\},*p=a+2； 则*P的值是3吗？不是，a不能加2，是个定值  
16.设有程序段:char s\[ \]=”china”; char \*p ; p=s ;  
则下面叙述正确的是( D )。  
A: s和p完全相同  
B: 数组s中的内容和指针变量p中的内容相等  
C: s数组长度和p所指向的字符串长度相等  
D: *p与s\[0\]相等  
【解析】P是一个字符指针，指向的是s\[\]字符串的首地址  
s代表s\[\]中的首地址  
如果只有这2个选项的话，那就只能选A了  
你可以把这2个的值输出来看看，你就会发现，他们的值是一样的  
17.若有以下说明和语句：  
char language\[\]=\{“FORTRAN”,“BASIC”,“PASCAL”,“JAVA”,“C”\};  
char \* \* q;  
q=language +2;则语句printf (＂%o\\n＂, q )**C**  
A: 输出的是language\[3\]元素的地址  
B: 输出的是字符串PASCAL  
C: 输出的是language\[2\]元素的值，它是字符串PASCAL的首地址  
D: 格式说明不正确，无法得到确定的输出  
【解析】fortran是language\[0\],表达式*language\[1\]>\*language\[2\]在我们认为是对字符串basic与pascal进行比较,在运行过程中它先读入字符串的第一个字母,进行比较,如果一样就再读下一个字母,因此这里比较的是B与P  
18.已有函数max(a，b)，为了使函数指针变量p指向函数max，则下面选项中赋值方法正确的是( A)。  
A: p=max  
B: \*p=max  
C: p=max(a, b)  
D: \*p=max(a, b )  
【解析】定义：int (\*p)(int a, int b);  
p=max;  
调用：int n=(\*p)(a,b);  
这是正确的使用方法，对此我最如下解释。  
第一行定义一个指向函数的指针  
第二行把max函数的地址给指针p，即此时p的值是函数的首地址，  
第三行对函数进行调用（\*p）表示对p的内容所指向的那个地址进行取值，即运行函数  
19.若int (\*p)\[5\];，其中，p是\_\_\_\_C\_\_\_。  
A: 5个指向整型变量的指针  
B: 指向5个整型变量的函数指针  
C: 一个指向具有5个整型元素的一维数组的指针  
D: 具有5个指针元素的一维指针数组，每个元素都只能指向整型量  
【解析】定义  
20.若有定义：int (\*p)\[4\];则标识符p\_\_\_\_\_C\_\_\_\_\_\_\_。  
A: 是一个指向整型变量的指针  
B: 是一个指针数组名  
C: 是一个指针，它指向一个含有四个整型元素的一维数组  
D: 定义不合法  
【解析】定义  
21.设有以下定义:  
int a\[4\]\[3\]=\{1,2,3,4,5,6,7,8,9,10,11,12\};  
int (\*prt)\[3\]=a,\*p=a\[0\];  
则下列能够正确表达数组元素a\[1\]\[2\]的表达式是( D )。  
A: \*((\*prt+1))  
B: *(*(p+5))  
C: (*prt+1)+2  
D: ((a+1)+2)  
【解析】a\[1\]\[2\]是第二行第三个所以a\[1\]\[2\]=6  
数组是这样的  
1 2 3  
4 5 6  
7 8 9  
22.对于语句int pa\[5\]；下列描述中正确的是\_\_\_D\_\_\_\_.  
A: pa是一个指向数组的指针，所指向的数组是5个int型元素  
B: pa是一个指向某数组中第5个元素的指针，该元素是int型变量  
C: pa \[5\]表示某个元素的第5个元素的值  
D: pa是一个具有5个元素的指针数组，每个元素是一个int型指针  
【解析】pa是变量名称,\[\]优先级高于,所以pa是数组,数组的元素是int*  
23.以下程序有错，错误原因是\_\_\_\_\_A\_\_\_\_\_\_。  
main()  
\{int *p,i;  
char q,ch;  
p=&i; q=&ch; p=40; p=q;  
┆  
\}  
A: p和q的类型不一致，不能执行p=q；语句  
B: p中存放的是地址值，因此不能执行p=40；语句  
C: q没有指向具体的存储单元，所以q没有实际意义  
D: q虽然指向了具体的存储单元，但该单元中没有确定的值，所以不能执行p=q； 语句  
【解析】在该程序中，首先声明整型指针变量p和整型变量i，字符型指针变量q和字符型变量ch，将i的地址赋给指针变量p，将ch的地址赋给指针变量q，然后将40赋给p。此时，虽然q已经指向了一个具体的存储单元，但ch的值不确定，即*q没有确定的值，所以不能执行 \*p=\*q；语句。  
24.下述程序的输出结果是（ C ）  
main()  
\{  
int x=-1,y=4,k;  
k=x++<=0&&!(y–<=0);  
printf("%d,%d,%d",k,x,y);  
\}

A: 0,0,3  
B: 0,1,2  
C: 1,0,3  
D: 1,1,2  
【解析】运行  
25.有以下程序  
\#include <stdio.h>  
main()  
\{  
int x;  
scanf("%d",&x);  
if(x<=3); else  
if(x!=10) printf("%d\\n",x);  
\}  
程序运行时，输入的值在哪个范围才会有输出结果（ A ）  
A: 大于3且不等于10的整数  
B: 小于3的整数  
C: 不等于10的整数  
D: 大于3或等于10的整数  
【解析】运行  
26.已知 int x=10, y=20, z=30; 以下语句执行后x, y, z的值是（ B ）。  
if(x>y)  
z=x;x=y;y=z;  
A: x=10,y=20,z=30　  
B: x=20,y=30,z=30  
C: x=20,y=30,z=10　  
D: x=20,y=30,z=20  
【解析】if（x>y)Z=X；  
如果X>Y 执行Z=X，因为X不大于Y，所以Z=X这句话不执行，继续向下执行  
X=Y;  
X=20  
Y=Z;  
Y=30  
Z还是原来的30  
27.下面判断正确的是\_\_\_\_\_\_A\_\_\_\_\_\_。  
A: char \*a=“china”;等价于char \*a; a=“china”;  
B: char str\[10\]=\{“china”\};等价于char str\[10\];str\[\]=\{“china”\};  
C: char \*s=”china”;等价于char \*s; *s=”china”;  
D: char c\[4\]=”abc”,d\[4\]=”abc”;等价于char c\[4\]=d\[4\]=”abc";  
【解析】A肯定是错的,char a; 那么a就是a\[0\]只能给它赋值一个字符而不是字符串,但由于a没有被赋值,所以也不能对*a赋值B也是错的,str\[\]只能是在声明时这么用,其它在其它地方出现\[\]中必须要有下标D是错的,char c\[4\]…  
28.若有以下定义，且0≤i＜4，则不正确的赋值语句是\_\_\_B\_\_\_\_.  
int b\[4\]\[6\], \*p, *q\[4\];  
A: q\[i\] = b\[i\];  
B: p = b;  
C: p = b\[i\]  
D: q\[i\] = &b\[0\]\[0\];  
【解析】A：q是一个指针数组，本质是一个一维数组，b\[i\]相当于将二维数组拆开成一个一位数组，每个元素还是包含多个元素的一位数组，本质一样，所以可以赋值。  
B：p是一个int型指针，而b是一个二维数组名，某些环境运行不会出错，但严谨意义上是不允许的，b,b\[0\],&b\[0\]\[0\],结果都是b\[0\]\[0\]的地址，但是三个方式的类型不完全相同，b是int(*)\[\]型，b\[0\]是int *型，&b\[0\]\[0\]是int*型，而指针p是int *型，所以p=b犯了类型不同的错误。  
C：理由同B，p和b\[i\]类型相同，所以可以赋值。  
D：q是一个指针数组，每个元素也是一个指针，q\[i\]里边存放某个数据的地址，而&b\[0\]\[0\]是b\[0\]\[0\]的地址，所以可以赋值。  
29.若有说明：int*p1,\*p2,m=5,n;以下程序段正确的是（D ）  
A: p1=&m;p2=&p1  
B: p1=&n;scanf("%d",\*p1)  
C: scanf("%d",n); \*p1=n  
D: p1=&n; \*p1=m  
【解析】 A.p2=&p1，p2不是双指针  
B，p2=&n，n还没有赋值  
C，正确  
D，\*p2=\*p1;原来p2还没初始化，即没有分配内存  
应该这样：p2=new int\[1\];\*p2=\*p1;  
30.已有定义int k=2,\*ptrl,\*ptr2;且ptr1和ptr2均已指向变量k，下面不能正确执行的赋值语句是（ B）  
A: k=\*ptr1+\*ptr2  
B: ptr2=k  
C: ptr1=ptr2  
D: k=*ptr1*(\*ptr2)  
【解析】 ptr2 是指针 ， k 是int型变量

判断题：  
1.定义结构体typedef struct one \{ int a;\}s; s a;则a为结构体变量（T）  
2.定义：char p\[20\]; 则，p, &p\[0\] 两者没有区别（T）  
3. 所有的函数调用前都必须进行函数原型说明。（F）  
【解析】不用先定义 定义可以放在程序最后 但在前面程序中加入函数原型即声明.  
4. 设有如下定义：  
　　char \*s\[2\]=\{“abcd”，“ABCD”\}；  
　　则s数组元素的值分别是“abcd”和“ABCD”两个字符串的首地址（T）  
5.函数指针所指向的是程序代码区。（T）  
6.char *name\[5\]定义一个一维指针数组，它有5个元素，每个元素都是指向字符数据的指针型数据。（T）  
7.指向同一数组的两个指针p1,p2相减的结果与所指元素的下标相减的结果是相同的。（T）  
8.若有以下说明：int a\[5\]\[9\]；则下列选项中对数组元素a\[i\]\[j\]的引用是错误的有*(a+i)\[j\].（0<=i<4，0<=j<9)（F）  
【解析】2维数组不能表示为a\[\]或者a 要表示某个元素要用a\[x\]\[y\]来表示比如a\[1\]\[1\]。  
9.字符指针是指向字符串的指针，可以用字符串常量给字符指针赋值。（T）  
10. 一个指针变量的值是一个地址值。（T）

[20191229144823878.jpg]: https://img-blog.csdnimg.cn/20191229144823878.jpg