C语言易错选择判断题

选择题：
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
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(10sizeof(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 )。

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
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.若有说明：intp1,*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）