嵌入式C--高级编程.doc

《嵌入式C++面向对象高级编程》考试试题
《嵌入式C++面向对象高级编程》笔试试卷
请将填空题的答案填入表格中
1
2
3
4
5
6
7
8
9
10
A
D
B
D
D
D
A
C
C
D
11
12
13
14
15
16
17
18
19
20
A
A
B
B
B
B
D
C
C
B
21
22
23
24
25
26
27
28
29
30
A
A
C
A
C
D
A

一、选择题
1. 下列关于类和对象的叙述中，错误的是( ) （2分）
 A一个类只能有一个对象 
 B.对象是类的具体实例 
 C.类是对某一类对象的抽象 
 D.类和对象的关系是一种数据类型与变量的关系 
2. 当将一个类A或函数f()说明为另一个类B的友元后，类A或函数f()能够直接访问类B的( )。 （2分）
 A.只能是公有成员 
 B.只能是保护成员 
 C.只能是除私有成员之外的任何成员 
 D.任何权限的成员 
3. 类中定义的成员默认为( )访问属性。 （2分）
 A.public 
 B.private 
 C.protected 
 D.friend 
4. 一个类的友元不是该类的成员与该类的关系密切，所以它( )。 （2分）
 A.有this指针，有默认操作的对象 
 B.没有this指针，可以有默认操作的对象 
 C.有this指针，不能执行默认操作 
 D.没有this指针，也就没有默认操作的对象 
5. 假定AA为一个类，a为该类私有的数据成员，GetValue( )为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为( )。 （2分）
 A.x.a 
 B.x.a() 
 C.x->GetValue() 
 D.x.GetValue() 
6. 对于任一个类，用户所能定义的构造函数的个数至多为( )。 （2分）
 A.0 
 B.1 
 C.2 
 D.任意个 
7. 一个类的析构函数通常被定义为该类的( )成员。 （2分）
 A.私有 
 B.保护 
 C.公用 
 D.友元 
8. 有如下类声明：class Foo ｛int bar; ｝;则Foo类的成员bar是 （ ） （2分）
 A.公有数据成员 
 B.公有成员函数 
 C.私有数据成员 
 D.私有成员函数 
9. 关于封装，下列说法中不正确的是( )。 （2分）
 A.通过封装，对象的全部属性和操作结合在一起，形成一个整体 
 B.通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见） 
 C.通过封装，每个对象都成为相对独立的实体 
 D.通过封装，对象的属性都是不可见的 
10. 假定AB为一个类，则执行 “AB *s=new AB(a,5);”语句时得到的一个动态对象为( )。 （2分）
 A.s 
 B.s->a 
 C.s.a 
 D.*s 
11. 对于一个类的构造函数，其函数名与类名( )。 （2分）
 A.完全相同 
 B.基本相同 
 C.不相同 
 D.无关系 
12. 在一个类的定义中，包含有( )成员的定义。 （2分）
 A.数据 
 B.函数 
 C.数据和函数 
 D.数据或函数 
13. 假定AB为一个类，则执行AB x；语句时将自动调用该类的( )。 （2分）
 A.有参构造函数 
 B.无参构造函数 
 C.拷贝构造函数 
 D.赋值构造函数 
14. 若类X是类Y的友元类，则下列哪种访问关系是正确的 （2分）
 A.类X的成员不能访问类Y的私有成员 
 B.类X的成员可以访问类Y的私有成员 
 C.类Y的成员可以访问类X的私有成员 
 D.只有类Y的公共成员才能访问类X的私有成员 
15. 假定AB为一个类，则执行 “AB a, b(3), *p;”语句时共调用该类构造函数的次数为( )。 （2分）
 A.2 
 B.3 
 C.4 
 D.5 
16. 在C++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为( )指针。 （2分）
 A.对象 
 B.派生 
 C.基类 
 D.this 
17. 静态数据成员的初始化是在( )中进行的。 （2分）
 A.构造函数 
 B.任何成员函数 
 C.所属类 
 D.类体外 
18. 对于公有继承，基类中的私有成员在派生类中将 ( )。 （2分）
 A.能够直接使用成员名访问 
 B.能够通过成员运算符访问 
 C.仍然是基类的私有成员 
 D.变为派生类的私有成员 
19. 建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为( )的构造函数。 （2分）
 A.自己所属类、对象成员所属类、基类 
 B.对象成员所属类、基类、自己所属类 
 C.基类、对象成员所属类、自己所属类 
 D.基类、自己所属类、对象成员所属类 
20. 派生类的成员函数可以直接访问基类的（ ）成员。 （2分）
 A.所有 
 B.公有和保护 
 C.保护和私有 
 D.私有 
21. 在c++中，一个虚函数是通过关键字( )放在其基类说明的前面来加以说明的. （2分）
 A.virtual 
 B.protected 
 C.operator 
 D.this 
22. 在C++中，对于基类的protected成员，当以protected方式派生一个新类时。该成员将成 为派生类的( )成员。 （2分）
 A.private 
 B.protected 
 C.public 
 D.非法 
23. 面向对象方法的多态性是指（ ）。 （2分）
 A.一个类可以派生出多个特殊类 
 B.一个对象在不同的运行环境中可以有不同的变体 
 C.针对一消息，不同的对象可以以适合自身的方式加以响应 
 D.一个对象可以是由多个其他对象组合而成的 
24. 抽象类是（ ）： （2分）
 A.不可以定义对象 
 B.可以定义对象 
 C.不可以派生新类 
 D.不可以输出 
25. 假定k是一个double类型的变量，则关于变量p的正确定义语句为( )。 （2分）
 A.double p=&k; 
 B.int *p=&k; 
 C.double *p=&k; 
 D.char *p=”Thank you!”; 
26. 若有定义：int aa[8];则以下表达式中不能代表数组元素aa[1]的地址的是( )。 （2分）
 A.&aa[0]+1 
 B.&aa[1] 
 C.&aa[0]++ 
 D.aa+1 
27. 假定指针变量p定义为“int *p=new int;”，要释放p所指向的动态内存，应使用语句( )。 （2分）
 A.delete p; 
 B.delete *p; 
 C.delete &p; 
 D.delete []p; 
 二. 判断
1. 域运算符(::)描述的是类和成员之间的关系。
答：√
2. 静态成员函数只能访问静态成员变量。
答：√
3. 构造函数和析构函数都可以重载。
答：×
4. 在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
答：×
5. 抽象类不可以继承，只能派生
答：×
6. 类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。答：×

7. 友元函数的声明不受访问区域的影响。
答：×
8. 子类可以继承父类的所有成员。
答：×
9. 使用new申请的内存，在程序执行结束时，必须使用delete释放。
答：√
10. 类A是类B的友元，则类B一定是类A的友元。
答：×
11. 静态成员变量每个对象都有一份拷贝。
答：×
12. 子类可以改造从父类继承的成员。
答：√
三、问答题
 1. 什么是“引用”？申明和使用“引用要注意哪些问题？将“引用”作为函数参数有哪些特点?
答：引用是个别名，当建立引用的时候，程序用另一个变量或对象的名字初始化他。
引用只有申明，没有定义，只是对原来变量的别名，不占空间。
使用引用传参，避免了变量复制的开销。

2、C++中的继承有几种形式？ 各种方式中的派生类对基类成员的访问规则有什
答：3种。
public
private
protected
基类(父类)得私有成员,派生类(子类)都不能访问;
基类得公有成员,派生类得继承方式决定了其函数得形式!
基类得保护成员在派生类得公有继承中也是保护类型!

3、举一个多态的例子，并以C的格式给于定义和实现。
答：李氏兄妹属于李氏家族，李氏是基类（这里还是抽象的纯基类），李氏又派生出两个子类（李氏男和李氏女），李氏男会所有男子项目的比赛（李氏男的成员函数），李氏女会所有女子项目的比赛（李氏女的成员函数）。姓李的人都会发言（基类虚函数），李氏男和李氏女继承自李氏当然也会发言，只是男女说话声音不一样，内容也会又差异，给人感觉不同（李氏男和李氏女分别重新定义发言这个虚函数）。李氏两兄妹就是李氏男和李氏女两个类的实体。
class no_virtual
{
public:
void fun1() const{}
int fun2() const { return a; }
private:
int a;
}
class one_virtual
{
public:
virtual void fun1() const{}
int fun2() const { return a; }
private:
int a;
}

class two_virtual
{
public:
virtual void fun1() const{}
virtual int fun2() const { return a; }
private:
int a;
}

4、派生类的构造函数和父类构造函数的执行顺序？
答：先执行父类的构造函数。

5、什么是虚基类？他的作用是什么？
答：在继承中产生歧义的原因有可能是继承类继承了基类多次，从而产生了多个拷贝，即不止一次的通过多个路径继承类在内存中创建了基类成员的多份拷贝。虚基类的基本原则是在内存中只有基类成员的一份拷贝。这样，通过把基类继承声明为虚拟的，就只能继承基类的一份拷贝，从而消除歧义。

6、解释：深拷贝，浅拷贝。
答：当出现类的等号赋值时，会调用拷贝函数
在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。
但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。
深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。

四、看程序

题1.分析以下程序的执行结果
#include
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<1 2 3 4 5 6 7 8 9 10
先把A[10][10]每一位上赋值，两个下标只和为其值，在输出第二列的值。

题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（）;

｝
答： 输出： B::act1() called。
A类中act1是虚函数，在B类中被覆盖，执行B中的act1函数。《嵌入式C++高级编程》机试试卷
一、已知String类定义如下：
class String
{
public:
String(const char *str = NULL); // 通用构造函数
String(const String &another); // 拷贝构造函数
~ String(); // 析构函数
String & operater =(const String &rhs); // 赋值函数
private:
char *m_data; // 用于保存字符串
};
尝试写出类的成员函数实现。
构造
myString::myString(const char *str = NULL)
{ cout<<"myString(char*)\n";
data = NULL;
size_t len = 0;
if(str != NULL){len = strlen(str);}
this->data = new char[len + 1];
if(data != NULL && str != NULL)strcpy(data, str);
data[len] = '\0';
}
拷贝构造
myString::myString(const myString& other)
{
cout<<"myString(myString&)\n";
size_t len = strlen(other.data);
data = new char[len +1];
if(data != NULL)strcpy(data, other.data);
}
析构
~myString()
{
delete[] data;
}
赋值
myString& myString::operator =(const myString& other)
{
delete[] data;
cout<<"op (this = other) \n";
size_t len = strlen(other.data);
data = new char[len +1];
if(data != NULL)strcpy(data, other.data);
return *this;
}
二、在Time类中设计如下重载运算符函数：时间：小时、分、秒
实现加法、减法、前++、后++重载。
time.h
#include
#include
using namespace std;
class Time
{
public:
Time(unsigned, unsigned, unsigned);
Time(Time&);
~Time(){count--;}
void set(unsigned, unsigned, unsigned);
void display();
friend ostream& operator << (ostream&, const Time&);
friend istream& operator >> (istream&, Time&);
friend Time& operator ++ (Time&);
friend Time operator ++ (Time&, int);
friend Time& operator -- (Time&);
friend Time operator -- (Time&, int);
static void ret();
private:
static int count;
void suit();
unsigned min;
unsigned hou;
unsigned sec;

};
time.cpp
#include "class_time.h"
int Time::count = 0;
ostream& operator << (ostream& dest, const Time& other)
{
printf("%u:%u:%u", other.hou, other.min, other.sec);
return dest;
}
istream& operator >> (istream& dest, Time& other)
{
printf("[hou:min:sec]:");
fflush(stdout);
scanf("%u:%u:%u", &other.hou, &other.min, &other.sec);
other.suit();
return dest;
}
Time::Time(unsigned a = 0, unsigned b = 0, unsigned c = 0)
{
count++;
hou = a;
min = b;
sec = c;
suit();
}
Time::Time(Time& other)
{
count++;
this->hou = other.hou;
this->min = other.min;
this>sec = other.sec;
}
void Time::display()
{
cout << hou << ":" << min << ":" << sec << endl;
}

void Time::suit()
{
if (sec > 60)
{
while (sec > 60)
{
sec -= 60;
min++;
}
}
if (min > 60)
{
while (min > 60)
{
min -= 60;
hou++;
}
}
if (hou > 24)
{
while (hou > 24)
{
hou -= 24;
}
}
}
void Time::set(unsigned a = 0, unsigned b = 0, unsigned c = 0)
{

hou = a;
min = b;
sec = c;
suit();
}
/*前增 ，先增在用*/
Time& operator ++ (Time& other)
{
other.sec++;
other.suit();
return other;
}
/*后增 ，先用在增*/
Time operator ++ (Time& other, int)
{
Time tmp(other);
other.sec++;
other.suit();
return tmp;
}
/*前减 ，先减在用*/
Time& operator -- (Time& other)
{
if (other.sec != 0)
{
other.sec--;
}
else
{
if (other.min != 0)
{
other.min--;
other.sec = 59;
}
else
{
if (other.hou != 0)
{
other.hou--;
other.min = 59;
other.sec = 59;
}
else
{
other.min = other.sec = 59;
other.hou = 23;
}
}
}
return other;
}
Time operator + (Time& one, const Time& anone)
{
one.sec = one.sec + anone.sec;
one.min = one.min + anone.min;
one.hou = one.hou + anone.hou;
one.suit();
return one;
}
Time operator - (Time& other, const Time& one)
{
if (other.sec >= one.sec)
{
other.sec = other.sec - one.sec;
}
else
{
if (other.min != 0)
{
other.min--;
other.sec = 60 + other.sec - one.sec;
}
else
{
if (other.hou != 0)
{
other.hou--;
other.min = 59;
other.sec = 59;
}
else
{
other.min = other.sec = 59;
other.hou = 23;
}
}
}
return other;
}
/*后减 ，先用在减*/
Time operator -- (Time& other, int)
{
Time tmp(other);
#if 0
if ((other.sec == 0) && (other.sec = 59))
{
if ((other.min == 0) && (other.min = 59))
{
if ((other.hou == 0) && (other.hou = 23)){}
else{}
}
}
#endif
#if 1
if (other.sec != 0)
{
other.sec--;
}
else
{
if (other.min != 0)
{
other.min--;
other.sec = 59;
}
else
{
if (other.hou != 0)
{
other.hou--;
other.min = 59;
other.sec = 59;
}
else
{
other.min = other.sec = 59;
other.hou = 23;
}
}
}
#endif
return tmp;
}
void Time::ret()
{
cout << count;
}
int main()
{
Time a;
Time b(12, 12);
Time c(0, 0, 1);
cout << c++ << endl;
cout << c << endl;
cout << ++c << endl;
cout << "========" << endl;
cout << c-- << endl;
cout << c << endl;
cout << --c << endl;
cout << "========" << endl;
cin >> c;
cout << c;
Time::ret();
return 0;
}
三、环形缓冲区的C++实现(申请一块内存，作为缓冲区)
接口可以对buf的读写。当空间不够时可以自动增加。

四、系统功能分析
学生成绩管理系统的功能需求分析 :学生成绩管理系统主要提供学生资料的输入,学生资料的输出,学生资料的查询,学生资料删除,以及学生成绩的排序等.编程的体会心得:通过这次对学生成绩管理系统的编写,使我对现在所学的东西和以前所学的东西有了同一的了解,综合的运用,使我从中学到了很多很多......
整个管理系统的框架是这样的：先定义一个结构，再定义一个类，其中类中包含输入成员函数，输出成员函数，查找成员函数，排序成员函数，删除成员函数以及检查函数。主界面在主程序中输出。然后根据使用者输入的需要使用的模块所对应的（1-6数字，而由主函数调用相对应的函数，完成使用者的需要，并且在主程序的开头还有对当前系统时间和日期的显示。
该程序共由六个模块构成，分别是：输入模块，输出模块，查找模块，删除模块，排序模块，退出模块。各模块的功能如下：
输入模块：该模块用于接收用户输入的学生信息。
输出模块：该模块用于输出用户输入的学生信息。
查找模块：按照用户输入的学号进行查找相对应的学生信息，如果找到便显示该生信息；否则，显示未找到。
删除模块：按照用户输入的学号进行查找相对应的学生信息，如果找到便显示该生信息并询问是否删除该信息，如果选择“是”就彻底删除该生信息；否则显示“未删除”，如果查找不到显示“未找到”。
排序模块：按照总分进行从大到小的排序并显示排序后的学生信息。
退出模块：退出该程序。

五、实现类函数：
/**************************************************
　　 这是CBrowseDir的类定义

/**************************************************
class CBrowseDir
{
protected:
//存放初始目录的绝对路径，以'\'结尾
char m_szInitDir[_MAX_PATH];

public:

//缺省构造器
CBrowseDir();

//设置初始目录为dir，如果返回false，表示目录不可用
bool SetInitDir(const char *dir);

//开始遍历初始目录及其子目录下由filespec指定类型的文件
//filespec可以使用通配符 * ?，不能包含路径。
//如果返回false，表示遍历过程被用户中止
bool BeginBrowse(const char *filespec);

protected:
//遍历目录dir下由filespec指定的文件
//对于子目录,采用迭代的方法
//如果返回false,表示中止遍历文件
bool BrowseDir(const char *dir,const char *filespec);

//函数BrowseDir每找到一个文件,就调用ProcessFile
//并把文件名作为参数传递过去
//如果返回false,表示中止遍历文件
//用户可以覆写该函数,加入自己的处理代码
virtual bool ProcessFile(const char *filename);

//函数BrowseDir每进入一个目录,就调用ProcessDir
//并把正在处理的目录名及上一级目录名作为参数传递过去
//如果正在处理的是初始目录,则parentdir=NULL
//用户可以覆写该函数,加入自己的处理代码
//比如用户可以在这里统计子目录的个数
virtual void ProcessDir(const char
*currentdir,const char *parentdir);
};

17