c++第一周测验

1

单选(1分)

下面程序片段哪个没错？

得分/总分

A.

int n = 4;

int & r = n * 5;
B.

int n = 6;

const int & r = n;

r = 7;
C.

int n = 8;

const int & r1 = n;

int & r2 = r1;
D.

int n = 8;

int & r1 = n;

const int r2 = r1;

1.00/1.00

2

单选(1分)

下面程序片段输出结果是什么？

int a = 1,b = 2;

int & r = a;

r = b;

r = 7;

cout << a << endl;

得分/总分

A.

1
B.

2
C.

7

1.00/1.00
D.

8

3

单选(1分)

下面说法哪种是对的？

得分/总分

A.

常引用所引用的变量，其值不能被修改
B.

不能通过常量指针，去修改其指向的变量

1.00/1.00
C.

常量指针一旦指向某个变量，就不能再指向其他变量
D.

1+1 = 3

4

单选(1分)

表达式 “new int”的返回值类型是：

得分/总分

A.

int
B.

int *

1.00/1.00
C.

int &
D.

void

5

单选(1分)

下面小段程序，哪个是正确的：

得分/总分

A.

char * p = new char[10];

p[0] = 'K';

delete [] p;

1.00/1.00
B.

int *p = new int[25];

p[10] = 100;

delete p
C.

char * p = new int;

p = 'a';

delete p;
D.

int * p = new char[20];

6

单选(1分)

下面说法正确的是：

得分/总分

A.

多个重载函数的参数个数必须不同。
B.

两个函数，参数表相同，返回值类型不同，它们是重载关系。
C.

调用一个第二个和第三个参数都有有缺省值的函数时，可以不写第二个实参而写第三个实参。
D.

使用内联函数的目的是提高程序的运行速度。

1.00/1.00

填空（2分）简单的swap 通过码是 ( 请参考公告中的“关于编程作业的说明”完成编程作业（请注意，编程题都要求提交通过码，在openjudge上提交了程序并且通过以后，就可以下载到通过码。)

　　总时间限制: 1000ms 内存限制: 65536kB　　

描述：填空，使得程序输出结果是：5,3

 
                #include <iostream> 
               
                using  
                namespace  
                std; 
               
                class  
                A 
               
                { 
               
                public 
                : 
               
                int  
                x; 
               
                int  
                getX() {  
                return  
                x; }    
               
                }; 
               
                void  
                swap( 
               
                // 在此处补充你的代码 
               
                ) 
               
                { 
               
                int   
                tmp = a.x; 
               
                a.x = b.x; 
               
                b.x = tmp; 
               
                } 
               
                int  
                main() 
               
                { 
               
                A a,b; 
               
                a.x = 3; 
               
                b.x = 5; 
               
                swap(a,b); 
               
                cout << a.getX() <<  
                ","  
                << b.getX(); 
               
                return  
                0; 
               
                }

　　输入无输出5,3

　　答案：

8 填空(2分) 难一点的swap

　　填空，使得程序输出结果是：5,3

 
                 #include <iostream> 
                
                 using  
                 namespace  
                 std; 
                
                 void  
                 swap( 
                
                 // 在此处补充你的代码 
                
                 ) 
                
                 { 
                
                 int  
                 * tmp = a; 
                
                 a = b; 
                
                 b = tmp; 
                
                 } 
                
                 int  
                 main() 
                
                 { 
                
                 int  
                 a = 3,b = 5; 
                
                 int  
                 * pa = & a; 
                
                 int  
                 * pb = & b; 
                
                 swap(pa,pb); 
                
                 cout << *pa <<  
                 ","  
                 << * pb; 
                
                 return  
                 0; 
                
                 }

　答案：

9 填空(2分) 好怪异的返回值

　填空，使得程序输出指定结果

 
                  #include <iostream> 
                 
                  using  
                  namespace  
                  std; 
                 
                  // 在此处补充你的代码 
                 
                  getElement( 
                  int  
                  * a,  
                  int  
                  i) 
                 
                  { 
                 
                  return  
                  a[i]; 
                 
                  } 
                 
                  int  
                  main() 
                 
                  { 
                 
                  int  
                  a[] = {1,2,3}; 
                 
                  getElement(a,1) = 10; 
                 
                  cout << a[1] ; 
                 
                  return  
                  0; 
                 
                  }

　　输入无输出 10

答案：

 
             int  
             &

10 填空(2分) 神秘的数组初始化

 
                  #include <iostream> 
                 
                  using  
                  namespace  
                  std; 
                 
                  int  
                  main() 
                 
                  { 
                 
                  int  
                  * a[] = { 
                 
                  // 在此处补充你的代码 
                 
                  }; 
                 
                  *a[2] = 123; 
                 
                  a[3][5] = 456; 
                 
                  if 
                  (! a[0] ) { 
                 
                  cout << * a[2] <<  
                  ","  
                  << a[3][5]; 
                 
                  } 
                 
                  return  
                  0; 
                 
                  }

　　输入无输出 123,456

答案：

免责声明！