···
一、选择题（每题1分，共计27x1'=27分）
1.C++对C语言作了很多改进，下列描述中（ ）使得
C语言发生了质变，从面向过程变成了面向对象。
A、增加了一些新的运算符；
B、允许函数重载，并允许设置缺省参数；
C、规定函数说明必须用原型；
D、引进了类和对象的概念；
2.静态数据成员的初始化必须在（）。
A、类内。
B、类外。
C、在构造函数内。
D、静态成员函数内。
3.在C++类中定义和实现的函数称为（）。
A、静态成员函数。
B、常成员函数。
C、内联函数。
D、一般函数。
4.一个类的友元不是该类的成员，与该类的关系密切，所以它( )。
A.有this指针，有默认操作的对象
B.没有this指针，可以有默认操作的对象
C.有this指针，不能执行默认操作
D.没有this指针，也就没有默认操作的对象
5.关于函数模板，描述错误的是（）
A.函数模板必须由程序员实例化为可执行的函数模板
B.函数模板的实例化由编译器实现
C.一个类定义中，只要有一个函数模板，则这个类是类模板
D.类模板的成员函数都是函数模板，类模板实例化后，成员函数也随之实例化
6.对于任一个类，用户所能定义的构造函数的个数至多为( )。
A.0
B.1
C.2
D.任意个
7.在C++中，要实现动态联编，必须使用（）调用虚函数
A.类名
B.派生类指针
C.对象名
D.基类指针
8.在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序()
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.关键字friend用于声明友元
B.一个类的成员函数可以是另一个类的友元
C.友元函数访问对象的成员不受访问特性影响
D.友元函数通过this指针访问对象成员
12.在C++中，类与类之间的继承关系具有（）
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++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为( )指针。
A.对象
B.派生
C.基类
D.this
17.关于delete运算符的下列描述中，（）是错误的。
A、它必须用于new返回的指针；
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.关于this指针的说法错误的是（ ）
A.this指针必须显示说明
B.当创建一个对象后，this指针就指向该对象
C.成员函数拥有this指针
D.静态成员函数不拥有this指针
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.如果A类型是B类型的子类型，A类型必然适应于B类型。
2.多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺 序。
3.单继承情况下，派生类中对基类成员的访问也会出现二义性。
4.C++程序一般应当含有main函数，它是C++程序执行的入口。
5.C++语言的标识符是不区分大小写的。
6.用new动态分配的内存是在堆中分配的，而不是在栈中分配的。
7.友元函数的声明不受访问区域的影响。
8.子类可以继承父类的所有成员。
9.使用new申请的内存，在程序执行结束时，必须使用delete释放。
10.类A是类B的友元，则类B一定是类A的友元。
11.静态成员变量每个对象都有一份拷贝
12.子类可以改造从父类继承的成员。
三、问答题（每题3分，共计6x3'=18分）

1. C++中引用和指针的区别？
   2、C++中的继承有几种形式？ 各种方式中的派生类对基类成员的访问规则有什
   3、在C++程序中调用被C编译器编译后的函数，为什么要加extern “C”？
   4、派生类的构造函数和父类构造函数的执行顺序？
   5、什么是虚基类？他的作用是什么？
   6、解释：深拷贝，浅拷贝。
   四、看程序（每题1.5分，共计2x1.5'=3分）
   题1.该程序执行后的输出结果是什么?
   int func(x)
   {
   int countx=0;
   while(x)
   {
   countx++;
   x=x&(x-1);
   }
   return countx;
   }
   int main()
   {
   cout<<func(9999)<<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; //用于保存字符串
}；
写出类的成员函数的具体功能实现代码。
二、设向量X=(x1,x2,...,x10)和Y=(y1,y2,...,y10),它们之间的加、减分别定义为：
X+Y=(x1+y1,x2+y2,...,x10+y10) X-Y=(x1-y1,x2-y2,...,x10-y10) 编程定义向量类Vector ,重载运算符”+”、”-“、”=”,实现向量之间的加、减和赋值运算;用重载运算符”>>”、”<<”做向量的输入/输出操作。注意检测运算的合法性。（10分）
三、从键盘输入一个字符串，将其中的大写字母全部转换成小写字母，然后存入到文件名为“text”的磁盘文件中保存。输入的字符串以“$”结束。。（8分）

答案

一，选择

1. D    2. B    3. C   4. D    5. A    
 6. D   7. D   8. B    9. B   10. D
11. D   12. C   13. B  14. B   15. A  
 16. D  17. C   18. C   19. C  20. B
21. A   22. B   23. C  24. A   25. A 
26. C  27. A
二，判断
1. T    2. T    3. F   
4. T    5. F    6. T   
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的个数。
====== 机试
一
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<<" "; 
          } 
}