整理笔记-day05

1、

有以下程序

1 2 3 4 5 6 7 8

#include<iostream> #include<cstdio> using namespace std; int main(){   int m=0123, n = 123;   printf("%o %o\n", m, n);   return 0; }

程序运行后的输出结果是(C)

A.0123 0173

B.0123 173

C.123 173

D.173 173

2、

运行以下程序后，如果从键盘上输入 65 14<回车>，则输出结果为（C）

1 2 3 4 5 6 7 8 9 10 11

int main(void) {      int m, n;     printf("Enter m,n;");     scanf("%d%d", &m,&n);     while (m!=n) {         while (m>n) m=m-n;         while (n>m) n=n-m;     }     printf("m=%d\n",m);     return 0; }

A.m=3

B.m=2

C.m=1

D.m=0

 解析：辗转相除法，求最大公约数

3、

数组a的定义为：int a[3][4]; 下面哪个不能表示 a[1][1] ?

正确答案: C   

A.*(&a[0][0]+5)

B.*(*(a+1)+1)

C.*(&a[1]+1)

D.*(a[1]+1)

二维数组中a[1]表示的是a[1][0]的地址，数组在内存中连续存储，所以a[1]+1表示的是a[1][1]的地址，所以D可以取得正确的值；

指针操作*(a+1)与a[1]等价，所以B也可以取得正确的值；

二维数组在内存中是行优先存储的，所以A中a[0][0]的地址加5可以取得正确值；

C选项错误，应改为*(&a[1][0]+1)，因为a[1]就表示a[1][0]的地址。

4、下面这段程序的输出是什么？

#include<stdio.h>
class A{
    public:
        A(){ p(); }
        virtual void p(){ printf("A"); }
        virtual ~A(){ p(); }
};
class B:public A{
    public:
        B(){ p(); }
        void p(){ printf("B"); }
        ~B(){ p(); }
};
int main(int, char**){
        A* a = new B();
        delete a;
}

答案：ABBA

解析：题目想构造一个B类的对象，B继承自A，所以首先构造A，A中构造函数调用P，虽然P是虚函数，按理来说应该动态绑定，但是此时B并没有被构造，所以只能调用自己的P函数（输出A），接下来构造B，调用B的P函数（输出B），接着西沟从派生类到基类，首先析构B，调用B的P函数（输出B），接着调用A的析构函数，按理来说应该动态绑定，但是此时B已经被析构，所以只能调用自己的P函数（输出A）。

5、如下函数在执行f(10)的时候调用了（）次

int f(int x){
if(x<=2) return 1;
return f(x-2)+f(x-4)+1;
}

正确答案为15次。递归树

f(10) = f(8) + f(6) + 1

        = (f(6) + f(4) + 1) + (f(4) + f(2) + 1) + 1

        = (f(4) + f(2) + 1) + (f(2) + f(0) + 1) + 1 + (f(2) + f(0) + 1) + 1 + 1 + 1

        = (f(2) + f(0) + 1) + 12

6、

下面程序执行后s的值为（D）

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

#include <stdio.h> int main() {     int i=1, j=3, k=0, sum=5;     switch(k > -i++) {         case 2: sum += 1;          case 1: sum += j;         case 0: sum += i; break;         case -1: sum *= -1;     }     printf("%d",sum);            return 0; }

A.5

B.6

C.9

D.10

执行到case 0时i已经变成2了 

函数重载是指在同一作用域内，可以有一组相同函数名，不同参数列表的函数，这组函数被称为重载函数。不同的参数列表包括，参数的个数、类型或者顺序必须不同。

7、

当n=5时，下列函数的返回值是（）

复制代码

1 2 3 4 5 6 7

int foo(int n){  if(n<2){    return n; }  else    return 2*foo(n-1)+foo(n-2); }

正确答案: C   

5

11

29

10

解析：

8、有以下程序

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

#include <stdio. h> int fun( int a ) {     int b = 0;     static int c = 3;     a = ( c + +,b + + );     return ( a ); } main( ) {     int a = 2,i,k;     for( i = 0;i<2;i + + )         k = fun( a + + );     printf("%d\n",k ); }

程序的输出结果是？

正确答案: B   

4

0

1

2

题目中fun函数被执行了两次,两次执行后,都是返回了函数内部的b值,所以答案为0,即B选项正确。

fun函数返回的a值和传入的a值无关，每次循环得到的k值和上一次循环也无关，所以直接看最后一次循环结果就好，不过要注意c值和fun()函数的调用次数是有关的。

结果的关键在于逗号表达式 a=(c++,b++); 看了大家的解析，想要提一点，以下两个表达式结果是不同的：

1. a=(表达式1,表达式2);
2. a=表达式1,表达式2;

因为逗号运算符在所有运算符中优先级最低，所以表达式（2）实际上执行过程为 (a=表达式1),表达式2; 所以这道题中：

1. 若 a=(c++,b++); 则a=0，因为逗号表达式为(c++,b++)，这个表达式的结果是0，并将这个结果赋值给a；
2. 若 a=c++,b++; 则a=4，因为逗号表达式为(a=c++,b++)，这个表达式结果为0，但赋给a的值是自加前的c值；

下面简单讲下逗号表达式是什么鬼：

逗号表达式的形式就是用逗号运算符将若干个表达式分隔开，形如：

表达式1,表达式2,......,表达式n

它是一个整体，所以上式其实是（表达式1,表达式2,......,表达式n ），运算过程为从左往右逐个表达式计算，整个表达式结果是表达式n的

假设在上下文和头文件正常的情况以下，下面程序的结果是什么（）

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

char* f(char *str, char ch) {     char *it1 = str;     char *it2 = str;     while (*it2 != '\0') {         while (*it2 == ch) { it2++; }         *it1++ = *it2++;      }     return str; } int main(int argc, char *argv[]) {     char *a = new char[10];     strcpy(a, "abcdcccd");     cout << f(a, 'c'); }

正确答案: D   

abdcccd

abdd

abcc

abddcccd

 指针进行赋值时，只是做了值覆盖，没有进行clean ，所以会有原值存在