c++测试4-5.txt

C++例子 此例子是课后练习

一. 单选题 （共29题,共93分）  
1. 在C++程序中，访问内存的方法包括：（ ） （3分） 
 A.寻址访问、调用访问  
 B.以上都不包括  
 C.引用访问、传址访问  
 D.直接访问、间接访问  

2. a[3][4]是一个int型二维数组，下列关于数组名a的说法中，不正确的为：（ ） （3分） 
 A.数组名a是一个指针，它表示数组的起始地址  
 B.数组名a是一个二级指针，它指向一个一维数组  
 C.数组名a指向a[0][0]  
 D.数组名a指向a[0]  

3. 已知：类A是一个组合类，它包含有类B的对象作为成员对象，下面给出这两个类的定义：
class B
{
   public:
       B(int,int);
   private:
       int x;
       int y;
};
B::B(int a,int b)
{
   x=a;
   y=b;
}
class A
{
   public:
       A(int,int,float);
   private:
       B obj;
       float r;
};
那么A的构造函数的定义为：（ ） （4分） 
 A. A::A(int a,int b,float c)
{
   obj.x=a;
   obj.y=b;
   r=c;
}  
 B. A::A(int a,int b,float c): obj(a,b)
{
   r=c;
}  
 C. A::A(int a,int b,float c)
{
   x=a;
   y=b;
   r=c;
}  
 D. A::A(int a,int b,float c): B(a,b)
{
   r=c;
}  

4. 长方形rectangle类的定义如下：
class rectangle
{
   public:
    rectangle(float w=1,float h=1);
   private:
    float width;
    float height;
}; 
现在定义该类的一个对象r,下面定义语句不正确的为:（ ） （3分） 
 A.rectangle r;  
 B.rectangle r();  
 C.rectangle r(2);  
 D.rectangle r(2,2);  

5. 下面定义语句的描述中，不正确的是：（ ） （3分） 
 A.int a[4][4]; —— a为int型的一级指针  
 B.float (*p)[4]; —— p为指向一维数组的指针  
 C.int **p; —— p为int型的二级指针  
 D.float *p[4]; —— p为长度为4的指针数组  

6. 分析下面关于构造函数和析构函数的陈述，判断正确的为：（ ）
陈述1：构造函数是用来完成对象的初始化工作，它会在定义对象时被自动调用
陈述2：析构函数是用来完成对象消亡前的清理工作，它会在对象消亡前被自动调用 （3分） 
 A.陈述1不正确，陈述2正确  
 B.两个陈述都正确  
 C.两个陈述都不正确  
 D.陈述1正确，陈述2不正确  

7. 分析下面关于析构函数的陈述，判断正确的为：（ ）
陈述1：析构函数不能被重载，一个类只能有一个析构函数
陈述2：析构函数名与类名相同，它的访问属性为private （3分） 
 A.两个陈述都正确  
 B.陈述1正确，陈述2不正确  
 C.两个陈述都不正确  
 D.陈述1不正确，陈述2正确  

8. 分析下面程序：
#include <iostream.h>
class point
{
   public:
    point(float,float);
   private:
    float x=0.0;
    float y;
};
point::point(float a,float b)
{
   x=a;
   y=b;
   cout<<"x="<<x<<"的构造函数被调用"<<endl;
}
int main()
{
   point p(2.3,4.5);
   return 0;
}
判断结果正确的是：（ ） （3分） 
 A.编译失败，由于属性x不能在定义的同时被初始化  
 B.编译成功，执行没有输出  
 C.编译成功，执行输出：x=2.3的构造函数被调用  
 D.编译成功，执行输出：x=0.0的构造函数被调用  

9. 下面给出四个字符串定义语句，其中会导致编译错误的为：（ ） （3分） 
 A.char str[6]="hello";  
 B.char str[6]="123456";  
 C.char *p="abc123";  
 D.string str("ABC");  
 
10. 已知：int a[10] , *p=a，以下等价关系不正确的为：（ ） （3分） 
 A.a[i]==(*a)+i  
 B.a[i]==*(p+i)  
 C.a[i]==*(a+i)  
 D.a==&a[0]  
 
11. d[5]是一个double型的一维数组，已知数组的起始地址为0x11AA2304，那么第3个元素的地址为：（ ） （4分） 
 A.0x11AA2306  
 B.0x11AA2314  
 C.0x11AA2307  
 D.0x11AA2320  
 
12. 下面定义二维数组的语句，哪个不正确？（ ） （3分） 
 A.int a[2][3] = {1,2,3,4,5,6};  
 B.int a[2][3] = {{1},{3}};  
 C.int a[2][3] = {{1,2,3},{4,5,6}};  
 D.int a[][] = {{1,2,3,4,5,6},{1,2,3,4,5,6},{1,2,3,4,5,6}};  
 
13. 下列关于类成员访问属性的说法中，正确的是：（ ） （3分） 
 A.默认访问属性为：friendly  
 B.默认访问属性为：public  
 C.默认访问属性为：protected  
 D.默认访问属性为：private  

14. 下面四组选项中，哪一项不完全属于面向对象的要素：（ ） （3分） 
 A.对象、类、消息  
 B.对象、消息、多态  
 C.结构体、对象、数组  
 D.类、消息、继承  

15. 分析以下程序：
   #include<iostream.h>
   #include<string.h>
   int main()
   {
       char str1[20]="ADF";
       char str2[20]="aff&&";
       cout<<"strcat(str1,str2)="<<strcat(str1,str2)<<endl;
       cout<<"strcpy(str1,str2)="<<strcpy(str1,str2)<<endl;    
       return 0;
   }
   其运行结果为：（ ） （3分） 
 A.strcat(str1,str2)=ADF
strcpy(str1,str2)=aff&&ADF  
 B.strcat(str1,str2)=aff&&
strcpy(str1,str2)=ADFaff&&  
 C.strcat(str1,str2)=ADFaff&&
strcpy(str1,str2)=aff&&  
 D.strcat(str1,str2)=aff&&ADF
strcpy(str1,str2)=ADF  

16. 以下程序应用了函数的三种调用方式,
   #include <iostream.h>    
   int main()
   {
       void change(int a,int &b,int *c);
       int a=3,b=4,c=5;
       change(a,b,&c);
       cout<<"a="<<a<<",b="<<b<<",c="<<c<<endl;        
       return 0;
   }
   void change(int a,int &b,int *c)
   {
       a++;
       b++;
       (*c)++;
   }
   其运行结果为：（ ） （4分） 
 A.a=4,b=5,c=6  
 B.a=3,b=5,c=6  
 C.a=3,b=5,c=5  
 D.a=4,b=5,c=5  

17. a[8]是一个int型的一维数组，以下关于它的说法中，不正确的是：（ ） （3分） 
 A.数组的长度为8，表示它可以存储8个int型变量  
 B.数组a所占的内存空间为32个字节  
 C.数组名a表示第一个元素a[1]的地址  
 D.数组名a表示数组在内存的起始地址  

18. a[5][5]是一个int型二维数组，对元素a[2][3]的访问方法不包括：（ ） （4分） 
 A.*&(a[2][3])  
 B.**(a+2+3)  
 C.*(*(a+2)+3)  
 D.*(a[2]+3)  
 
19. 下面给出两个关于一维数组赋初值的陈述：
   陈述1：如果对数组的全体元素赋初值，则可以省略数组长度
   陈述2：如果只对数组的部分元素赋初值，则也可以省略数组长度
   以下选项中判断正确的为：（ ） （3分） 
 A.两个陈述都不正确  
 B.陈述1正确，陈述2不正确  
 C.陈述1不正确，陈述2正确  
 D.两个陈述都正确  

20. 判断以下关于成员函数的两个陈述，判断正确的是：（ ）
陈述1：成员函数只可以在类内部定义，否则会产生编译错误
陈述2：如果成员函数在类内部定义，编译时自动会成为内联函数 （3分） 
 A.陈述1不正确，陈述2正确  
 B.陈述1正确，陈述2不正确  
 C.两个陈述都不正确  
 D.两个陈述都正确  

21. 下列关于计算机内存的说法中，不正确的为：（ ） （3分） 
 A.内存是以字节为单位来存储数据的  
 B.计算机给每个字节的内存空间分配一个编号，也就是所谓的内存地址  
 C.内存地址是连续的十六进制整数  
 D.一个内存空间可以有多个地址  

22. 下面关于成员函数的说法中，正确的是：（ ） （3分） 
 A.成员函数不允许重载  
 B.成员函数的访问属性只能是public  
 C.成员函数不允许有默认形参值  
 D.成员函数既可以定义在类内部，又可以定义在类外部  

23. 分析以下程序：
   #include<iostream.h>
   #include<string.h>
   int main()
   {
       char str1[20]="ADF";
       char str2[20]="aff&&";
       cout<<"strlen(str1)="<<strlen(str1)<<endl;
       cout<<"strcmp(str1,str2)="<<strcmp(str1,str2)<<endl;        
       return 0;
   }
   其运行结果为：（ ） （3分） 
 A.strlen(str1)=4
strcmp(str1,str2)=-1  
 B.strlen(str1)=3
strcmp(str1,str2)=1  
 C.strlen(str1)=4
strcmp(str1,str2)=1  
 D.strlen(str1)=3
strcmp(str1,str2)=-1  

24. 点point类的定义语句如下：
   class point
   {
       public:
           point(float a=0,float b=0);
       private:
           float x;
           float y;
   }
   下面选项中定义point对象数组的语句，错误的为：（ ） （3分） 
 A.point p[3];  
 B.point p[3]={1,2,3};  
 C.point p[3]={point(1,2),3,point(2,4)};  
 D.point p[3]={point(1,2), ,point(2,4)};  

25. 已知p是一个double型的指针变量，则sizeof(p)的值为：（ ） （3分） 
 A.4  
 B.1  
 C.8  
 D.以上都不正确  

26. 分析以下程序：
   #include <iostream.h>
   int main()
   {
       int add(int a[5]);
       int b[5]={1,2,3,4,5};
       cout<<add(b)<<endl;
       return 0;
   }
   int add(int a[5])
   {
       int s=0;
       int i;
       for(i=0;i<5;i++)
       {
           s=s+a[i];
       }
       return s;
   }
   其运行结果为：（ ） （4分） 
 A.运行输出：15  
 B.运行输出：10  
 C.数组越界，导致编译失败  
 D.运行没有输出  

27. a[3][4]是一个int型二维数组，已知a[0][0]的地址为0x11220000，则a[1][2]的地址为：（ ） （4分） 
 A.0x11220024  
 B.0x11220018  
 C.0x11220006  
 D.0x11220012  

28. 分析下面两个陈述，判断正确的是：（ ）
陈述1：面向对象程序设计比面向过程程序设计的可重用性好
陈述2：面向对象程序设计比面向过程程序设计的可扩充性好 （3分） 
 A.两个陈述都不正确  
 B.陈述1正确，陈述2不正确  
 C.陈述1不正确，陈述2正确  
 D.两个陈述都正确  

29. 下列关于构造函数的陈述中，不正确的为：（ ） （3分） 
 A.构造函数不能被重载，一个类只能有一个构造函数  
 B.构造函数是用来完成对象的初始化工作  
 C.构造函数无返回值，也不能把void写在构造函数名前面  
 D.构造函数名与类名相同  

 
 
 
 二. 判断题 （共6题,共7分）  
1. 在C++语言中，new运算符是用于动态内存分配的 （1分） 

2. 定义组合类的对象时，成员对象的构造函数比组合类的构造函数先调用 （1分） 

3. 在C++语言中，同一个数组内的元素可以是不同类型的数据 （1分） 

4. 面向对象程序设计方法，使得数据和操作数据的方法结合在一个类里面，因此能减少需要传递的参数，从而简化函数调用。 （2分） 

5. 编译预处理是指系统在程序执行前对程序所做的一些工作 （1分） 

6. 成员函数既可以在类内部声明，又可以在类外部声明 （1分）