C: a=a*b=b+c

char x=0xffff;
printf(“%dn”,x–);
上面程序段的运行结果是

A:-32767
B:fffe
C:-1
D:-32768
答案: -1

double d;
float f;
long l;
int i;
i=f=l=d=20/3;
printf(“%d,%1d,%.1f,%.1f,”,i,l,f,d);
上面程序段的运行结果是

A:6,6,6.0,6.0
B:6,6,6.7,6.7
C:6,6,6.0,6.7
D:6,6,6.7,6.0
答案: 6,6,6.0,6.0

unsigned a=65535;
printf(“%d,%o,%x”,a,a,a);
TC中整型变量占2个字节，则上面程序段的运行结果是

A:-1,177777,ffff
B:65535,65535,65535
C:-1,65535,ffff
D:65535,177777,ffff
答案: -1,177777,ffff

关于putchar()的说法正确的是

A:其作用由用户向计算机输出一个字符
B:putchar()函数括号中可以写字符变量或常量，也可以写整型变量或常量
C:putchar()可用于输出字符串
D:putchar()不能对转义字符进行操作
答案: putchar()函数括号中可以写字符变量或常量，也可以写整型变量或常量

要从键盘给两个整型变量ab输入数据，输入格式是1,2，能完成此任务的代码是

A:getchar(a,b);
B:scanf(“%d%d”,a,b);
C:scanf(“%d,%d”,&a,&b);
D:scanf(“%d%d”,&a,&b);
答案: scanf(“%d,%d”,&a,&b);

想通过代码“scanf(“%d%d,%d”,&a,&b,&c);”把3分别存入3个整型变量abc，则正确的键盘输入应该是

A:1,2,3
B:12,3
C:1 23
D:123
答案: 12,3

关于格式控制字符串%-m.ns,正确的说法是

A:m表示输出的字符串最少占m列，n为小数精度
B:如果n>m，则只截取m个字符，其余的舍弃
C:如果n>m，则截取n个字符输出，突破m的限制
D:如果n，则字符串向右靠拢，左端补0
答案: 如果n>m，则截取n个字符输出，突破m的限制

以下不属于格式控制字符的是

A:%f
B:%D
C:%E
D:%X
答案: %D

abc都是整型变量，用“scanf(“%d %2d %*2d %d”,&a,&b,&c);”给3个变量输入数据，设输入格式是12 34 56 78,则3个变量的值分别是

A:12,34,56
B:12,34,78
C:1,34,78
D:1,34,7
答案: 12,34,78

char c1=”1″,c2=”2″;
c1=getchar();
c2=getchar();
上面的程序段运行时从键盘输入a,则正确的叙述是

A:c1被赋予字符a,c2被赋予换行符
B:程序将等待输入第二个字符
C:c1被赋予字符a,c2维持原值
D:c1被赋予字符a,c2无确定值
答案: c1被赋予字符a,c2被赋予换行符

int i;
float f;
scanf(“i=%d,f=%f”,&a,&f);
上面程序段准备把10和5.12分别存给i和f，正确的输入是（）。

A:105.12
B:i=10,f=5.12
C:105.12
D:i=10f=5.12
答案: i=10,f=5.12

int a;
char b;
float c;
scanf(“%d%c%f”,&a,&b,&c);
若上面程序段运行时键盘输入的字符序列为2223a123o.12,则abc的值分别是

A:原值不变
B:2223，a,123o.12
C:2223,a,原值
D:2223,a,123
答案: 2223,a,123

int a=3,b=2,c=1,f;
f=a>b>c;
上面程序段执行后，f的值是

A:1
B:0
C:2
D:不确定
答案: 0

#include
void main ( )
{
int a=1,b=2,m=0,n=0,k;
k=(n=b>a)||(m=a  printf (“%d,%d”,k,m);
}
);
上面程序的运行结果是

A:0,0
B:0,1
C:1,0
D:1,1
答案: 1,0

以下四个选项中，执行完程序段后y的值不为3的是

A:int x=5,y=2; if(x) y=3;
B:int x=5,y=2; if(2) y=3;
C:int x=0,y=2; if(x=y) y=3;
D:int x=0,y=0; if(x=y) y=3;
答案: int x=0,y=0; if(x=y) y=3;

int a=2,b=-1,c=2;
if(a if(b c=0;
else c++;
)
上面的程序段执行后，c的值是

A:0
B:1
C:2
D:3
答案: 2

int x=10,y=20,z=30;
if(x>y)
z=x;x=y;y=z;
上面代码段执行后，x，y，z的值是

A:20,30,30
B:20,30,10
C:20,10,10
D:10,20,30
答案: 20,30,30

逻辑运算符中，运算优先级按从高到低正确排序的是

A:&& ! ||
B:|| && !
C:! || &&
D:! && ||
答案: ! && ||

以下是if语句的基本形式：

if(表达式)语句

其中“表达式”

A:必须是逻辑表达式
B:必须是关系表达式
C:必须是逻辑表达式或关系表达式
D:可以是任意合法的表达式
答案: 可以是任意合法的表达式

若有表达式(！w)?(–x):(++y),则下列选项中与其等价的表达式是

A:(w==1)?(–x):(++y)
B:(w==0)?(–x):(++y)
C:(w!=1)?(–x):(++y)
D:(w!=0)?(–x):(++y)
答案: (w==0)?(–x):(++y)

int w=”b”,x=14,y=15;
w=((x||y)&&(w 执行上面程序段后，w的值为

A:-1
B:NULL
C:1
D:0
答案: 0

if((x=y=2)>=x&&x=5)
y*=x;
上面程序段执行后，整型变量xy的值分别是

A:4
B:2
C:10
D:存在语法错误
答案: 存在语法错误

int x,y;
scanf(“%d%d”,&x,&y);
if(x>y)
x=y;y=x;
else
x++;y++;
printf(“%d,%d”,x,y);
关于上面程序段，下列说法正确的是

A:有语法错误
B:若输入“3 4”，输出“4,5”
C:若输入“4 3”，输出“3,4”
D:若输入“4 3”，输出“4,4”
答案: 有语法错误

1. #include
2. int main()
3. {
4. int m;
5. printf(“Input m: “);
6. scanf(“%d”, &m); //输入一个整数
7. if (m > 0) //是否为正数
8. {
9. if (m % 2 == 0) //是正数，且能被2整除，则是正偶数
10. {
11. printf(“%d is a positive evenn”, m);
12. }
13. else //不能被2整除，则是正奇数
14. {
15. printf(“%d is a positive oddn”, m);
16. }
17. }
18.
19. _______________ //判断是否为负数
20.
21. {
22. _______________
23.
24. {
25. printf(“%d is a negative evenn”, m); //是负偶数
26. }
27. else
28. {
29. printf(“%d is a negative oddn”, m); //是负奇数
30. }
31. }
32. else
33. {
34. printf(“%d is zero.It is an evenn”, m);
35. }
36. return 0;
37. }
上面程序代码的功能是判断输入整数的正负性和奇偶性，请将第19行和22行标号处缺少的代码填写完整

A:第19行代码： else if(m

第22行代码： if (m % 2 == 0)
B:第19行代码： else if(m

第22行代码： if (m % 2 != 0)
C:第19行代码： if(m

第22行代码： if (m % 2 != 0)

D:第19行代码： if(m

答案: 第19行代码： else if(m

第22行代码： if (m % 2 != 0)

以下程序段中,与语句: k=a>b?(b>c?1:0):0;功能相同的是

A:if((a>b)&&(b>c)) k=1; else k=0;
B:if((a>b)||(b>c)) k=1; else k=0;
C:if(a D:if(a>b) k=1; else if(b>c) k=1; else k=0;
答案: if((a>b)&&(b>c)) k=1; else k=0;

int x=1,a=0,b=0;
switch(x)
{
case 0:b++;
case 1:a++;
case 2:a++;b++;
}
上面程序段执行后，a，b的值分别是

A:2,1
B:1,1
C:1,0
D:2,2
答案: 2,1

int x=1,y=2,z=3;
switch(x=1){
case 1:
switch(y==2){
case 1:printf(“*”);break;
case 2:printf(“%”);break;
}
case 0:
switch(z){
case 1:printf(“$”);break;
case 2:printf(“&”);break;
default:printf(“#”);
}
}
上面程序段的运行结果是

A:*#
B:$
C:%#
D:*$
答案: *#

对于while语句,错误的说法是

A:可以用条件控制循环体的执行次数
B:循环体至少要执行一次
C:循环体有可能一次也不执行
D:循环体可以是包含若干条语句的复合语句
答案: 循环体至少要执行一次

对于整型变量x,与while(！x)等价的是

A:while(x！=0)
B:while(x！=1)
C:while(x==0)
D:while(x==1)
答案: while(x==0)

以下描述正确的是

A:由于do-while循环中循环体语句只能是一条可执行语句,所以循环体内不能使用复合语句
B:do-while循环由do开始,用while结束,在while(表达式)后面必须写分号
C:在do-while循环体中,一定要有能使while后面表达式的值变成零(“假”)的操作
D:do-while循环中,根据情况可以省略while
答案: do-while循环由do开始,用while结束,在while(表达式)后面必须写分号

#include
int main()
{
int x,i;
for(x=3;x if(x%2==0) _____;
for(i=2;i if(x%i==0) _____;
if(i==x) printf(“%d”,x);
}
return 0;
}
上面程序的功能是找出3～100间的素数,程序中所缺的两处应为

A:break break
B:continue continue
C:continue break
D:break continue
答案: continue break

设变量已正确定义,下面程序中能计算f=n!的是

A:f=0;for(i=1;i B:f=1;for(i=1;i
C:f=1;for(i=n;i>1;i++) f*=i;
D:f=1;for(i=n;i>=2;i–) f*=i;
答案: f=1;for(i=n;i>=2;i–) f*=i;;i++)>

#include
int main()
{
int x,s=0;
for(x=1;x switch(x%3){
case 0:
default:s+=3;
case 1:s+=1;break;
case 2:s+=2;
}
}
printf(“%d”,s);
return 0;
}
上面程序的运行结果是

A:6
B:7
C:10
D:13
答案: 10

#include
int main()
{
int i,j;
for(i=3;i>=1;i–)
{
for(j=1;j printf(“%d”,i+j);
printf(” “);
}
return 0;
}
上面程序的运行结果是

A:23 43 45
B:43 25 43
C:23 34 45
D:45 34 23
答案: 45 34 23

#include
int main()
{
int i=10,x=0;
for( ;i x=x+i;
printf(“%d”,x);
return 0;
}
上面程序运行后,循环体运行的次数为

A:10
B:0
C:1
D:无限
答案: 0

以下不是死循环的是

A:for(;;x+=k);
B:for (;(c=getchar())!=”n”;) printf(“%c”,c);
C:for (k=10;;k–) sum=sum+k;
D:while(1){x++;}
答案: for (;(c=getchar())!=”n”;) printf(“%c”,c);

以下正确的说法是

A:continue 语句的作用是结束整个循环的执行
B:只能在循环体内和switch语句内使用break语句
C:在循环体内使用break和continue的作用相同
D:从多层循环嵌套内退出时,只能使用goto语句
答案: 只能在循环体内和switch语句内使用break语句

有关for语句正确的是

A:只用于循环次数已经确定的情况
B:for循环是先执行循环体语句,后判断表达式
C:for循环中,不能用break跳出循环体
D:for语句的循环体只能是一条语句
答案: for语句的循环体只能是一条语句

#include
int main()
{
int i=1,n=1;
for( ;i {
continue;
n=n+i;
}
printf(“%d”,n);
return 0;
}
上面程序运行后,变量n的值为

A:4
B:3
C:2
D:1
答案: 1

#include
int main()
{
int x,s;
for(x=0,s=0;x {
if(x%3==0)
continue;
else
{
if(x%4==0)
continue;
else s+=x;
if(s%5==0) break;

}
}
printf(“%d”,s);
return 0;
}
上面程序的运行结果是

A:35
B:25
C:15
D:5
答案: 15

#include
int main()
{
int x=012;
do
printf(“%d”,x–);
while(–x);
return 0;
}
上面程序的运行结果是

A:86420
B:108642
C:10864
D:8642
答案: 108642

#include
int main()
{
int s=0,i=5;
while(s+=i,i-=2)
printf(“%d”,s);
return 0;
}
上面程序的运行后,循环的执行次数是

A:5
B:9
C:15
D:死循环
答案: 死循环

fun(float x)
{
float y;
long z;
y=x*x;
z=(long)y;
return(z);
}
上面fun函数的类型是

A:void
B:int
C:long
D:float
答案: int

以下正确的函数声明形式是

A:double fun(x,y);
B:double fun(int x; int y);
C:double fun(int x, y);
D:double fun(int x, int y);
答案: double fun(int x, int y);

有以下函数定义:void fun(int n,double x) {…} ,若以下选项中的变量都已经正确定义且赋值,则对函数fun的正确调用语句是

A:fun(int y,double m);
B:k=fun(10,12.5);
C:fun(10,12.5);
D:void fun(n,x);
答案: fun(10,12.5);

#include
int a, b;
void swap( )
{
int t;
t=a; a=b; b=t;
}
int main()
{
scanf(“%d,%d”, &a, &b);
swap( );
printf (“a=%d,b=%dn”,a,b);
return 0;
}
假设用户输入5,3,上面程序的运行结果是

A:a=5,b=3
B:a=3,b=5
C:5,3
D:3,5
答案: a=3,b=5

#include
void fun (int a,int b,int c)
{
a=456;
b=567;
c=678;
}
int main()
{
int x=10, y=20,z=30;
fun (x,y,z);
printf(“%d,%d,%dn”,x,y,z);
return 0;
}
上面程序的运行结果是

A:30,20,10
B:10,20,30
C:456567678
D:678567456
答案: 10,20,30

#include
void f(int x)
{ }
int main()
{
int a=1;
f(a);
return 0;
}
若有上面的程序,其中正确的是

A:x是形参,a是形参
B:x是形参,a是实参
C:x是实参,a是形参
D:x是实参,a是实参
答案: x是形参,a是实参

以下不正确的说法是,C语言规定

A:实参可以是常量变量或表达式
B:形参可以是常量变量或表达式
C:实参个数与其对应的形参个数必须相等
D:实参应与其对应的形参类型一致或者兼容
答案: 形参可以是常量变量或表达式

#include
long fib(int g)
{
switch(g)
{
case 0:return 0;
case 1:
case 2:return 1;
}
return ;
}
int main()
{
long k;
k=fib(7);
printf(“k=%ldn”,k);
}
上面的程序用递归定义的方法实现求菲波拉契数列8……第7项的值为fib(7),请将程序补充完整.

A:fib(7)
B:fib(g)+fib(g-1)
C:fib(g)+fib(g)
D:fib(g-1)+fib(g-2)
答案: fib(g-1)+fib(g-2)

以下对函数的描述中正确的是

A:调用函数时,只能把实参值传给形参,形参值不能传给实参
B:函数既可以嵌套定义又可以嵌套调用
C:函数必须有返回值,否则不能使用函数
D:自定义函数不可以去调用主函数
答案: 调用函数时,只能把实参值传给形参,形参值不能传给实参

若调用一个函数,且此函数中没有return语句,则正确的说法是该函数

A:没有返回值
B:返回若干个系统默认值
C:返回一个用户所希望的函数值
D:返回一个不确定的值
答案: 返回一个不确定的值

#include
int fun(int n)
{
if(n==1)
return 1;
else
return(n+fun(n-1));

}
int main(){
int x;
scanf(“%d”,&x);
x=fun(x);
printf(“%d”,x);
return 0;
}
若输入10,上面的程序运行结果是

A:55
B:54
C:65
D:45
答案: 55

函数调用时,若实参是变量,则实参和它对应的形参之间的传递方式是

A:双向传递
B:单向传递
C:由实参传给形参，再由形参传回给实参
D:由用户指定的传递方式
答案: 单向传递

C语言允许函数值类型缺省定义,此时该函数值隐含的类型是

A:float型
B:int型
C:long型
D:double 型
答案: int型

关于C语言函数的描述中,正确的是

A:函数的定义可以嵌套,但函数的调用不可以嵌套
B:函数的定义不可以嵌套,但函数的调用可以嵌套
C:函数的定义和函数的调用都可以嵌套
D:函数的定义和函数的调用都不可以嵌套
答案: 函数的定义不可以嵌套,但函数的调用可以嵌套

若在一个函数的复合语句中定义了一个变量，则该变量

A:只在该复合语句中有效
B:在该函数中有效
C:在本源文件范围内有效
D:定义非法
答案: 只在该复合语句中有效

某源文件中定义了一个全局变量，其作用范围是

A:整个源文件的范围
B:所有源文件
C:从定义处到本源文件结束
D:不知道有无声明，所以不确定
答案: 不知道有无声明，所以不确定

在函数体中定义的局部变量，其作用范围是

A:定义它的函数内
B:定义它的大括号内
C:定义它的源文件内
D:所有源文件
答案: 定义它的大括号内

函数形参的声明不在任何大括号内，关于形参，下列说法正确的是

A:形参是全局变量
B:形参只是一个符号，不表示变量
C:形参是动态局部变量
D:形参是静态局部变量
答案: 形参是动态局部变量

函数中未指定存储类型的局部变量，其存储类型是

A:static
B:extern
C:auto
D:register
答案: auto

关于静态局部变量，正确的说法是

A:

程序装载时分配空间，程序结束时才释放空间

B:

执行到它的作用域时分配空间，离开它的作用域时释放空间

C:

从分配空间到程序结束，它一直存在，期间在任何地方都可以使用它

D:

其他几种说法都不对

答案:

程序装载时分配空间，程序结束时才释放空间

定义了一个变量但未赋初值，关于它的初值，下面说法正确的是

A:若是static型的全局变量，为0；若是extern型的全局变量，则不确定
B:若是全局变量，则为0；若是局部变量，则不确定
C:若是静态局部变量，则为0；若是自动变量或寄存器变量，则不确定
D:若是动态存储，则为0；若是静态存储，则不确定
答案: 若是静态局部变量，则为0；若是自动变量或寄存器变量，则不确定

关于全局变量的生存期，下面说法正确的是

A:从程序装载到程序运行结束

B:取决于它定义的位置
C:取决于它所在的函数
D:从源文件开始执行到源文件执行结束
答案: 从程序装载到程序运行结束

若全局变量定义时未规定属性，则它的属性是

A:static
B:extern
C:auto
D:register
答案: extern

#include
int a=2,b=3;
int max(int a,int b)
{
int c;
c=a>b?a:b;
printf(“%d”,c);
return c;
}
int main()
{
int a=4;
max(a,b);
printf(“%d”,max(a,b));
return 0;
}
上面程序的运行结果是

A:24
B:4
C:34
D:444
答案: 444

int fac (int n)
{
static int f=1;
f*=n;
return f;
}
int main()
{
int i,n;
for(i=1;i n=fac(i);
printf(“%d”,n);
return 0;
}
上面程序的运行结果是

A:5
B:24
C:100
D:120
答案: 120

根据变量的作用域将变量分为

A:全局变量和局部变量
B:静态变量和动态变量
C:自动变量和临时变量
D:自动变量和寄存器变量
答案: 全局变量和局部变量

全局变量和局部静态变量分配空间的时机是

A:主函数结束时
B:执行到作用域的时候
C:装载exe文件时
D:主函数执行时
答案: 装载exe文件时

下列变量在程序运行过程中不占内存空间的是

A:全局变量
B:自动局部变量
C:寄存器变量
D:静态局部变量
答案: 寄存器变量

下面哪种类别的变量允许在其它源文件中使用？

A:auto
B:register
C:extern
D:static
答案: extern

下面说法错误的是

A:宏展开只是简单地文字替换
B:宏展开能发现宏定义中的错误
C:宏展开不会出现编译错误
D:宏展开不会进行数据类型的判别
答案: 宏展开能发现宏定义中的错误

设有宏定义
#define PI 3.14159
在宏展开时，3.14159会被认为是

A:单精度实数
B:双精度实数
C:字符串
D:7个文字符号
答案: 7个文字符号

文件包含时，可以用也可以用””将被包含文件括起来，下面说法正确的是

A:两者作用相同
B:能用””的一般也可以用
C:能用的一般也可以用””
D:能用的不能用””，反之亦然
答案: 能用的一般也可以用””

文件包含命令中若用包括被包含的文件，表示

A:要到本源文件所在的目录中查找它
B:到系统设定的包含目录中查找它
C:既到系统设定的目录中查找，又到本源文件所在目录查找
D:其他几种说法都不对
答案: 到系统设定的包含目录中查找它

若有宏定义
#define N 2+1
则printf(“%d”,N*(N+1))的输出结果是

A:6
B:12
C:8
D:5
答案: 6

有一种方法可以避免一个文件的内容被包含两次或以上，该方法除了文件包含命令外，还需要使用

A:宏定义
B:条件编译
C:宏定义和条件编译
D:宏定义和分支结构
答案: 宏定义和条件编译

下面关于条件编译的说法，正确的是

A:条件编译就是在程序执行时，根据条件选择一部分代码执行
B:条件编译就是在正式编译时，根据条件选择一部分代码留下参与编译，另一部分舍弃
C:条件编译两个分支中若都有代码，则这两部分代码都要参加编译
D:若一个程序既能写成条件编译，又能写成分支结构，则用条件编译写成的源程序比用分支结构写成的源程序将来生成的可执行文件更短
答案: 若一个程序既能写成条件编译，又能写成分支结构，则用条件编译写成的源程序比用分支结构写成的源程序将来生成的可执行文件更短

若有定义
#define M(n) a=n*2
int a;
则printf(‘%d’,M(5+1)*3)的输出结果是

A:11
B:36
C:21
D:其他答案都不对
答案: 11

下面四段程序中，能正确输出变量a的值的是

A:int a=1,*p;
*p=a;
printf(“%d”,*p);
B:int a=1,*p=a; printf(“%d”,*p);
C:int a=1, *p=&a; printf(“%d”,*p);
D:int a=1, *p; *p=&a; printf(“%d”,*p);
答案: int a=1, *p=&a; printf(“%d”,*p);

要定义两个指针变量，下面代码正确的是

A:int *p1,*p2;
B:int *p1, int *p2;
C:int* p1,p2;
D:int *(p1，p2);
答案: int *p1,*p2;

若有定义：
int *p;
则以下说法正确的是

A:变量名为*p
B:变量类型为int
C:变量名为p
D:变量基类型为int*
答案: 变量名为p

若有定义
int x,*p;
则能使p指向x的表达式是

A:p=x
B:p=&x
C:*p=x
D:p=*x
答案: p=&x

若有定义：
int *p, a=1, b;
则以下正确的程序段是

A:p=&b;
scanf（”%d”，&p);
B:scanf(“%d”, &b）;
*p=b;
C:p=&b;
scanf(“%d”，*p);
D:p=&b;
scanf(“%d”，p)；
答案: p=&b;
scanf(“%d”，p)；

若有定义：
int a=511, *b=&a;
则printf(“%dn”, *b)的输出结果为

A:不确定值
B:a的地址
C:b的地址
D:511
答案: 511

以下对一维数组a的定义中正确的是

A:char a(10);
B:int a[0..100];
C:int a[5];
D:int k=10;int a[k];
答案: int a[5];

以下对一维数组的定义中不正确的是

A:double x[5]={2.0,4.0,6.0,8.0,10.0};
B:int y[5]={0,1,3,5,7,9};
C:char ch1[ ]={“1”, “2”, “3”, “4”, “5”};
D:char ch2[ ]={“x10”, “xa”, “x8”};
答案: int y[5]={0,1,3,5,7,9};

以下对二维数组的定义中正确的是

A:int a[4][]={1，2，3，4，5，6};
B:int a[][3];
C:int a[][3]= {1，2，3，4，5，6};
D:int a[][]＝{{1,2,3},{4,5,6}}
答案: int a[][3]= {1，2，3，4，5，6};

假定一个int型变量占用两个字节，若有定义：int x[10]={0,2,4}; 则数组x在内存中所占字节数是

A:3
B:6
C:10
D:20
答案: 20

#include
int main()
{
int a[4][4]= {{1,3,5},{2,4,6},{3,5,7}};
printf(“%d%d%d%dn”,a[0][3],a[1][2],a[2][1],a[3][0]);
}
上面程序的运行结果是

A:0650
B:1470
C:5430
D:输出值不定
答案: 0650

#include
int main()
{
int m[][3]= {1,4,7,2,5,8,3,6,9};
int i,j,k=2;
for(i=0; i printf(“%d “,m[k]);
}
return 0;
}
上面程序的运行结果是

A:4 5 6
B:2 5 8
C:3 6 9
D:7 8 9
答案: 3 6 9

#include
int main()
{
int b[3][3]= {0,1,2,0,1,2,0,1,2},i,j,t=0;
for(i=0; i for(j=i; j t=t+b[b[j][j]];
printf(“%dn”,t);
return 0;
}
上面程序的输出结果是

A:3
B:4
C:1
D:9
答案: 3

若有定义：int a[2][4];，则引用下标变量正确的是

A:a[0][3]
B:a[0][4]
C:a[2][2]
D:a[2][2+1]
答案: a[0][3]

若有定义：int aa[8];，则不能代表数组元素aa[1]地址的是

A:&aa[0]+1
B:&aa[1]
C:&aa[0]++
D:aa+1
答案: &aa[0]++

若二维数组y有m列，则排在y[j]前的元素个数为

A:j*m+i　
B:i*m+j
C:i*m+j-1　
D:i*m+j+1
答案: i*m+j

若定义一个名为s且初值为”123″的字符数组，则下列定义错误的是

A:char s[]={’1″，”2″，”3″，”[ck8_view=5]