**一、选择题（每题
1分，共计27x1'=27分）**
1.下列关于类和对象的叙述中，错误的是
( )
A.一个类只能有一个对象
B.对象是类的具体实例
C.类是对某一类对象的抽象
D.类和对象的关系是一种数据类型与变量的关系
2.当将一个类A或函数f()说明为另一个类B的友元后，类A或函数f()能够直接访问类B的( )。
A.只能是公有成员
B.只能是保护成员
C.只能是除私有成员之外的任何成员
D.任何权限的成员
3.类中定义的成员默认为( )访问属性。
A.public B.private C.protected D.friend
4.一个类的友元不是该类的成员，与该类的关系密切，所以它( )。
A.有this指针，有默认操作的对象
B.没有this指针，可以有默认操作的对象
C.有this指针，不能执行默认操作
D.没有this指针，也就没有默认操作的对象
5.假定AA为一个类，a为该类私有的数据成员，GetValue( )为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为( )。
A.x.a B.x.a() C.x->GetValue() D.x.GetValue()
6.对于任一个类，用户所能定义的构造函数的个数至多为( )
。
A.0 B.1 C.2 D.任意个
7.一个类的析构函数通常被定义为该类的( )成员。
A.私有
B.保护
C.公用
D.友元
8.有如下类声明：class Foo｛int bar;｝;则Foo类的成员bar是 （ ）
A.公有数据成员
B.公有成员函数
C.私有数据成员
D.私有成员函数
9.关于封装，下列说法中不正确的是( )。
A.通过封装，对象的全部属性和操作结合在一起，形成一个整体
B.通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
C.通过封装，每个对象都成为相对独立的实体
D.通过封装，对象的属性都是不可见的
10.假定AB为一个类，则执行 “AB *s=new AB(a,5);”语句时得到的一个动态对象为( )。 A.s B.s->a C.s.a D.*s 11.对于一个类的构造函数，其函数名与类名( )。
A.完全相同
B.基本相同
C.不相同
D.无关系
12.在一个类的定义中，包含有( )成员的定义。
A.数据
B.函数
C.数据和函数
D.数据或函数
13.假定AB为一个类，则执行AB x；语句时将自动调用该类的( )。
A.有参构造函数
B.无参构造函数
C.拷贝构造函数
D.赋值构造函数
14.若类X是类Y的友元类，则下列哪种访问关系是正确的
A.类X的成员不能访问类Y的私有成员
B.类X的成员可以访问类Y的私有成员
C.类Y的成员可以访类X的私有成员
D.只有类Y的公共成员才能访问类X的私有成员
15.假定AB为一个类，则执行 “AB a, b(3), *p;”语句时共调用该类构造函数的次数为( )。
A.2 B.3 C.4 D.5
16.在C++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为( )指针。（2分）
A.对象
B.派生
C.基类
D.this
17.静态数据成员的初始化是在( )中进行的。
A.构造函数
B.任何成员函数
C.所属类
D.类体外
18.对于公有继承，基类中的私有成员在派生类中将( )。
A.能够直接使用成员名访问
B.能够通过成员运算符访问
C.仍然是基类的私有成员
D.变为派生类的私有成员
19.建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺依次为( )的构造函数。
A.自己所属类、对象成员所属类、基类
B.对象成员所属类、基类、自己所属类
C.基类、对象成员所属类、自己所属类
D.基类、自己所属类、对象成员所属类
20.派生类的成员函数可以直接访问基类的（）成员。
A.所有
B.公有和保护
C.保护和私有
D.私有
21.在c++中，一个虚函数是通过关键字( )放在其基类说明的前面来加以说明的
.
A.virtual B.protected C.operator D.this
22.在C++中，对于基类的protected成员，当以protected方式派生一个新类时。该成员将成为派生类的( )成员.
A.private B.protected C.public D.非法
23.面向对象方法的多态性是指（）。
A.一个类可以派生出多个特殊类
B.一个对象在不同的运行环境中可以有不同的变体
C.针对一消息，不同的对象可以以适合自身的方式加以响应
D.一个对象可以是由多个其他对象组合而成的
24.抽象类是（）
A.不可以定义对象
B.可以定义对象
C.不可以派生新类
D.不可以输出
25.假定k是一个double类型的变量，则关于变量p的正确定义语句为( )。
A.double p=&k; B.int *p=&k; C.double *p=&k; D.char *p=”Thank you!”;
26.若有定义：int aa[8];则以下表达式中不能代表数组元素aa[1]的地址的是( )。
A.&aa[0]+1 B.&aa[1] C.&aa[0]++ D.aa+1
27.假定指针变量p定义为“int *p=new int;”，要释放p所指向的动态内存，应使用语句( )。
A.delete p; B.delete *p; C.delete &p; D.delete []p;
** 二.判断(每题2分，共计12x2'=24分
)******
1.域运算符(::)描述的是类和成员之间的关系。
2.静态成员函数只能访问静态成员变量。
3.构造函数和析构函数都可以重载。
4.在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
5. 抽象类不可以继承，只能派生
6. 类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。
7. 友元函数的声明不受访问区域的影响。
8. 子类可以继承父类的所有成员。
9. 使用new申请的内存，在程序执行结束时，必须使用delete释放。
10. 类A是类B的友元，则类B一定是类A的友元。
11. 静态成员变量每个对象都有一份拷贝。
12. 子类可以改造从父类继承的成员。**
三、问答题（每题3分，共计6x3'=18分）
1. 什么是“引用”？申明和使用“引用”要注意哪些问题？将“引用”作为函数参数有哪些特点?
2、C++中的继承有几种形式？ 各种方式中的派生类对基类成员的访问规则有什
3、举一个多态的例子，并以C++的格式给于定义和实现。
4、派生类的构造函数和父类构造函数的执行顺序？
5、什么是虚基类？他的作用是什么？
6、解释：深拷贝，浅拷贝。
**四、看程序（每题1.5分，共计2x1.5'=3分）**题
1.分析以下程序的执行结果
#include<iostream.h>
class Sample
{
int A[10][10];
public:
int &operator()(int,int);
};
int &Sample::operator()(int x,int y)
{
return A[x][y];
}
void main()
{
Sample a;
int i,j;
for(i=0;i<10;i++)
for(j=0;j<10;j++)
a(i,j)=i+j;
for(i=0;i<10;i++)
cout<<a(i,1)<<" ";
cout<<endl;
}
题2. 回答问题：①该程序执行后的输出结果是什么？为什么？
#include
class A
｛
public：
virtual void act1（）;
void act2（）
｛
act1（）;
｝
｝;
void A：：act1（）
｛
cout”A：：act1（） called。”
}
class B：public A
｛
public：
void act1（）;
｝
void B：：act1（）
｛
cout”B：：act1（） called。”
}
void main（）
｛
B b;
b.act2（）;
｝
《嵌入式C++高级编程》****机试试卷
一、已知
String类定义如下：（10分）
class String
{
public:
String(const char *str = NULL); //通用构造函数
String(const String &another); //拷贝构造函数
~ String(); //析构函数
String & operater =(const String &rhs); //赋值函数
private:
char *m_data; //用于保存字符串
};
写出类的成员函数的具体功能实现代码。
二、在Time类中设计如下重载运算符函数：时间：小时、分、秒
实现加法、减法、前++、后++重载。**（10分）**
三、使用文件相关的类，实现图片或mp3等文件的复制。**（8分）**
例如：./copyfile a.mp3 b.mp3
a.mp3是已经存在的mp3音频文件
,b.mp3是从a.mp3音频文件复制之后得到的新文件。
答案
C++考试题4_参考答案
一，选择
1. D 2. D 3. B 4. D 5. D 6. D 7. C 8. C 9. B 10. D
11. A 12. C 13. B 14. B 15. A 16. D 17. D 18. C 19. C 20. B
21. A 22. B 23. C 24. A 25. C 26. C 27. A
二，判断 2,7,9,12 T
1. F 2. T 3. F 4. F 5. F 6. F 7. T 8. F 9. T 10. F
11. F 12. T
三，问答
1. C++中引用和指针的区别？
引用是对象的别名， 操作引用就是操作这个对象， 必须在创建的同时有效得初始化（引用一个有效的对象， 不可为NULL）， 初始化完毕就再也不可改变， 引用具有指针的效率， 又具有变量使用的方便性和直观性， 在语言层面上引用和对象的用法一样， 在二进制层面上引用一般都是通过指针来实现的， 只是编译器帮我们完成了转换。 之所以使用引用是为了用适当的工具做恰如其分的事， 体现了最小特权原则。
2、C++中的继承有几种形式？ 各种方式中的派生类对基类成员的访问规则有什
派生继承，虚拟继承，多重继承
有三种形式：
方式 public protected private
1,Public public protected private
2,Protected protected protected private
3,Private private private private
3、在C++程序中调用被C 编译器编译后的函数，为什么要加extern “C”？
首先，作为extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。 在c++的环境下使用c 的函数时，通常会出现编译器无法找到 obj 模块中的c 函数定义的问题，从而导致链接失败。这时因为在c++ 中支持函数重载，编译时会将函数名和参数列表连接起来，而c 语言不会，因此会造成链接失败的情况，此时 c 函数就需要使用extern “C “ 来进行链接指定。
4、派生类的构造函数和父类构造函数的执行顺序？
顺序如下：
1， 虚基类构造函数
2， 非虚基类构造函数
3， 组合对象构造函数
4， 本身构造函数
5、什么是虚基类？他的作用是什么？
当继承时，加上virtual关键字，就是所谓的虚拟继承，该基类就是虚基类；
作用：当继承重复时，会出现继承模糊的问题，虚拟继承会解决这个问题，即没有继承的时候继承，如果继承了则不需要再重复继承。
6、解释：深拷贝，浅拷贝。
浅拷贝：拷贝构造函数简单地制作了一个该资源的复制，而不对指针指向的堆空间拷贝一个复本堆空间，这样两个对象共享同一个堆空间，当其中一个对象析构时，另一个对象的指针则变成野指针，并且堆空间将产生两次delete的错误；
深拷贝：拷贝构造函数对指针属性所指的堆空间，也进行深度的空间复制，这样，两个对象就有独立的空间和资源，这是深拷贝。
四 阅读
1. 答案：8
思路：将x转化为2进制，看含有的1的个数。
2. 输出B：：act1() called。
====== 机试
一
String::String(constchar*str)
{
if ( str == NULL ) // strlen在参数为NULL时会抛异常才会有这步判断
{
m_data =newchar[1] ;
m_data[0] ='\\0' ;
}
else
{
m_data =newchar[strlen(str) +1];
strcpy(m_data,str);
}
}
String::String(const String &another)
{
m_data =newchar[strlen(another.m_data) +1];
strcpy(m_data,other.m_data);
}
String& String::operator=(const String &rhs)
{
if ( this==&rhs)
return*this ;
delete []m_data; //删除原来的数据，新开一块内存
m_data =newchar[strlen(rhs.m_data) +1];
strcpy(m_data,rhs.m_data);
return*this ;
}
String::~String()
{
delete []m_data ;
}
二
#include <iostream.h> //
using namespace std;
class Vector
{
int vec[10];
public:
Vector(int v[10]);
Vector();
Vector(Vector&);
Vector operator+(Vector&);
Vector operator-(Vector&);
friend ostream& operator<<(ostream& out, Vector&);
};
Vector::Vector(int v[10])
{
int i;
for(i=0;i<10;i++)vec[i]=v[i];
}
Vector::Vector()
{ int i; for(i=0;i<10;i++)vec[i]=0; }
Vector::Vector(Vector& v)
{ int i; for(i=0;i<10;i++)vec[i]=v.vec[i]; }
Vector Vector::operator+(Vector& v)
{
Vector z; int i;
for(i=0;i<10;i++)z.vec[i]=vec[i]+v.vec[i];
return z;
}
Vector Vector::operator-(Vector& v)
{
Vector z; int i;
for(i=0;i<10;i++) z.vec[i]=vec[i]-v.vec[i];
return z;
}
ostream& operator<<(ostream& out, Vector& v)
{ for(int i=0;i<10;i++) out<<v.vec[i]<<","; return out; }
void main()
{
int a[10]={-4,1,0,10,5,-9,8,13,6,2,};
int b[10]={-11,8,10,17,-6,9,6,7,12,5};
Vector v1(a),v2(b),v3,v4;
v3=v1+v2;
v4=v2-v1;
cout<<v3<<endl;
cout<<v4<<endl;
}
三
#include < iostream >
#include < fstream >
using namespace std;
void main()
{
char a[100];
ofstream writeFile("text.txt");
int i;
while(1)
{
cin>>a;
if(a[0] == ’$’)
return;
i = 0;
while(a[i] != ’\\0’)
{
if( a[i]>=65 && a[i]<=90 )
a[i]=a[i] + 32;
i++;
}
writeFile<< a<<" ";
}
}
网友评论