整理笔记-day06

1、有以下函数定义：

1	void fun(int n, double x) {…}

若以下选项中的变量都已正确定义并赋值，则对函数fun的正确调用语句是（C）

A.fun(int y,double m);

B.k=fun(10,12.5);

C.fun(x,n);

void fun(n,x);

解析：A函数调用时不需要指明实参类型

B函数定义为void，所以k=错误

C正确。类型转换，最终形参类型都为double

D函数调用不需要指明函数类型

2、若有定义int*p[3];，则以下叙述中正确的是（）

答案：定义了一个指针数组p，该数组含有三个元素，每个元素都是指向int类型的指针

3、对于代码块

struct sk{int a;float b}data,*p=&data;

则对data中的a成员正确引用是（B）

(*p).data.a

(*p).a

p->data.a

p.data.a

解析：①如果是指针指向结构体，就用->(即为指针访问结构体成员的方式）

②结构体类型名访问结构体成员变量用.成员访问运算符

综上，可以用p->a或者（*p）.a

4、下列代码的输出是（）

1 2 3 4 5 6 7 8 9 10 11 12

#include<stdio.h> int main() {     const char *c[] = {"HELLO", "NEW", "WORLD", "SAYHI"};     const char **cp[] = {c + 3, c + 2, c + 1, c};     const char ***cpp = cp;     printf("%s,", **++cpp);     printf("%s,", *--*++cpp + 3);     printf("%s,", *cpp[-2] + 3);     printf("%s\n", cpp[-1][-1] + 1);     return 0; }

 

正确答案: D  

WORLD,LO,SAYHI,EW

WORLD,LO,HI,NEW

NEW,LO,SAYHI,EW

WORLD,LO,HI,EW

解析：

第一个printf：由于char***cpp，可以读成cpp为一个指向char**类型的指针，并且初始化为cp，而cp是一个指针数组，数组里面存储的类型为char**，也就是cpp指向cp[0]，故*cpp=cp[0]；因此++cpp使得cpp指向cp[1]，故*++cpp=cp[1]；而cp[1]是一个指向c[2]的指针，因此*cp[1] = c[2]，故**++cpp=*cp[1]=c[2]，故输出WORLD;

第二个printf：由优先级可得知，单目运算符高于算术运算符；而*和++是单目运算符，+是算术运算符，又cpp本身是指向的cp[1]，故++cpp使得cpp指向cp[2]，故*++cpp则为cp[2]，而此时的cp[2]是一个指向c[1]的地址，故对指向c[1]的指针cp[2]进行--，故使得cp[2]指向的是c[0]，故*--*++cpp+3=*--cp[2]+3=c[0]+3，而这里的c[0]，其实存放的是指向HELLO字符串的指针故c[0]+3，使得该指针指向HELLO中的第二个L的位置，故输入LO；

第三个printf：由于cpp目前指向的是cp[2]，而cpp[-2]是等于*(cpp-2)，而在第二个printf时cpp指向cp[2]，则*(cpp-2) = cp[0](注：这里cpp-2后，cpp本身的指针地址没有改变，因此在第四个printf中，cpp依旧是指向cp[2]),又cp[0]是一个指向c[3]的指针，对cp[0]进行*运算，使得*cp[0]=c[3]，故**(cpp-2)=*cpp[-2]=c[3]，同时c[3]是一个指向SAYHI的指针，故c[3]+3，使得指向H的位置，故输出HI；

第四个printf：在第三个printf并没有改变cpp的地址，故cpp依旧是指向cp[2]，又cpp[-1][-1]+1=*(*(cpp-1)-1)+1，故cpp-1，则cpp指向cp[2]，故*(cpp-1)=cp[1]；此时的cp[1]是一个指针，指向c[2]，故cp[1]-1是从指向c[2]的指针地址-1，故是指向c[1]，则*(*(cpp-1)-1)=*(cp[1]-1)=c[1]，故cpp[-1][-1]+1=*(*(cpp-1)-1)+1=c[1]+1，此时的c[1]同样是一个指针，故c[1]+1是指向NEW中的E的位置，故输出EW。

故答案是D。

5、

以下程序运行后的输出结果是（）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int main(){     int a[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {11, 12, 13, 14}, {15, 16, 17, 18}};     int i = 0, j = 0, s = 0;     while (i++ < 4){         if(i == 2||i == 4) continue;         j = 0;         do {             s += a[i][j];             j++;         } while(j < 4);     }     printf("%d\n", s);     return 0; }

答案：92

cuntinue 是短路本次循环，进入下次循环。

while(i++<4)时i已经从1开始了

所以结果是{5,6,7,8}和{15,16,17,18}的和

6、下面程序的运行结果是（）

1 2 3 4 5 6 7 8 9

int main() {     char ch[7] = {"65ab21"};     int i, s=0;     for(i = 0; ch[i] >= '0' && ch[i] <= '9'; i += 2)         s = 10*s + ch[i] - '0';     printf("%d\n", s);     return 0; }

 正确答案：6

【解释】进入for循环时，i的值为0，表达式(ch[i]>=’0’ && ch[i]<=’9’)是用来检测

ch[i]是否为数字字符，因为ch[0]是’6’，所以表达式为真，进入循环体中执行s=10*s+ch[i]

-‘0’;语句，该语句的功能就是将数字串转换成相应的整数，因s的初值为0，所以s的结

果为6。语句执行完后，再将i增2，再判断ch[2]是否为数字字符，因ch[2]是’a’，表达式

为假，循环退出。所以s的值输出为6，故正确答案是C.

7、

如下C语言程序段：

1 2	for(k=0; k<1000; k++)  a[k] = a[k]+32;

若数组a及变量k均为int型，int型数据占4B，数据Cache采用直接映射方式，数据区大小为1KB、块大小为16B，该程序段执行前Cache为空，则该程序段执行过程中访问数组a的Cache缺失率约为 （）

正确答案: C   

1.25%

2.5%

12.5%

25%

解析：

分析语句“a[k]=a[k]+32”：首先读取a[k]需要访问一次a[k]，之后将结果赋值给a[k]需要访问一次，共访问两次。第一次访问a[k]未命中，并将该字所在的主存块调入Cache对应的块中，对于该主存块中的4个整数的两次访问中只在访问第一次的第一个元素时发生缺失，其他的7次访问中全部命中，故该程序段执行过程中访问数组a的Cache缺失率约为1/8（即12.5%）。

8、

上下文及头文件均正常的情况下，以下程序的输出结果是__9______。

1 2 3 4 5 6 7 8 9

void fut(int**s,int p[2][3]) {     **s=p[1][1]; } void main( ) {     int a[2][3]={1,3,5,7,9,11},*p;     p=(int*)malloc(sizeof(int));     fut(&p,a);     cout<< *p; }

解析： fut函数有两个形参，一个二级指针，和一个二维数组。函数作用是把二级指针双重解引用也就是一级指针指向[1][1]。实参传递了一级指针的地址，也就是把p指向[1][1]。所以解引用之后的值为9。

9、外部变量可以供其所在的程序文件中的任何函数使用，这句话是错误的。

解析：全局变量也称外部变量，它是函数外部定义的变量，其作用域是从定义该变量的位置开始至源文件结束。全局变量不受作用域的影响（全局变量的生命期一直到程序的结束）

如果在一个文件中使用extern关键字来声明另一个文件中存在的全局变量，那么这个文件可以使用这个数据

在全局变量前加一个static，使该变量只在这个源文件中可用，称之为全局静态变量。

10、求函数返回值，输入x=9999

int func(int x){
int count=0;
while(x){
count++;
x=x&(x-1);
}
return count;
}

 答案：一个数与这个数减1的结果进行按位与&运算，结果是：这个数二进制数最右边的1变为0；

题中count是用以统计x的二进制中1的个数的，9999的二进制表示为：1001 1100 001111共有8个1.

11、数组定义为“int a[4];”,表达式（D）是错误的。

*a

a[0]

a

a++

解析：数组中a指的是数组首地址，地址是常量，不可以自加

软件根据其用途分为两大类：系统软件和应用软件。各种语言的编译程序都

是属于系统软件。操作系统和数据库管理系统都是具体的软件，均属于系统软件。

12、下面程序的输出结果为多少（32位机器上）？

void Func(char str_arg[2])
{
int m=sizeof(str_arg);
int n=strlen(str_arg);
printf("%d\n",m);
printf("%d\n",n);
}
int main(void){
char str[]="hello";
Func(str);
}

 解析：当数组作为函数的参数时，其自动转换为指向函数的指针。

Which of following C++ code is correct?

A.int f(){int *a=new int(3);return *a;}

B.int *f(){int a[3]={1,2,3};return a;

C.vector<int>f(){vector<int>v(3);return v;}

D.void (int*ret){int a[3]={1,2,3};ret=a++;return;

解析：

因为C不存在内存泄漏的问题且可以得到想要结果，但除D外所有选项都是可以编译通过的，无语法错误。A是内存泄漏，没有delete.B数组是临时的，根本传不到主调函数里，D不能对数组变量做++操作。