第一篇：《C++面向对象程序设计》谭浩强版复习总结
第一章 C++ 基础
endl 换行并刷新输出流
setw(n)设置字段位数为n hex,oct,dec 十六进制，八进制，十进制表示 setfill 定义填充字符
setprecision 定义浮点数的精度 left,right 左对齐，右对齐
showpoint 强制显示小数点以及全部尾部0 C++通过给常量命名的方式定义常量：
const<数据类型名><常量名>=<表达式> 用const定义的标识符常量时，一定要对其初始化。在说明时进行初始化是对这种常量置值的唯一方法，不能用赋值运算符对这种常量进行赋值。函数声明的一般形式为
函数类型 函数名（参数表）函数模板的定义
template
函数定义
例子：template
template
定义
对变量起另外一个名字(别名alias)，这个名字称为该变量的引用。<类型>&<引用变量名> = <原变量名>；
其中原变量名必须是一个已定义过的变量。如：
int
max;
int &refmax=max;refmax并没有重新在内存中开辟单元，只是引用max的单元。max与refmax在内存中占用同一地址，即同一地址两个名字。对引用类型的变量，说明以下几点：
1、引用在定义的时候要初始化
2、对引用的操作就是对被引用的变量的操作。
3、引用类型变量的初始化值不能是一个常数。
4、一旦引用被声明，它就不能再指向其它的变量。
5、对引用的初始化，可以用一个变量名，也可以用另一个引用。
6、引用同变量一样有地址，可以对其地址进行操作，即将其地址赋给一指针。当&m的前面有类型符时（如int &m），它必然是对引用的声明；如果前面无类型符（如cout<<&m）,则是取变量的地址。
7、对常量（用const声明）的引用使用如下方式： int i=5;const int &a=i;内联函数定义的一般格式为：
inline <函数值类型><函数名>(<参数表>){ <函数体> } 作用域运算符
::a表示全局作用域中的变量a。注意：不能用::访问函数中的局部变量
new运算从堆中分配一块与<类型>相适应的大小为<元素个数>的数组存储空间，若分配成功，将这块存储空间的起始地址存入<指针变量名>，否则置<指针变量名>的值为NULL（空指针值，即0）。new的使用格式为：
<指针变量名>=new <类型>[<元素个数>];delete运算符用来释放<指针变量名>指向的动态存储空间。使用格式如下：
delete <指针变量名> 或
delete[] <指针变量名>
第2章 面向对象基本概念
面向过程编程与面向对象编程的区别：
面向过程编程先确定算法，再确定数据结构； 面向对象编程先确定数据结构，再确定运算。类定义：
class <类名> { <访问控制符>: <成员函数的声明> <访问控制符>: <数据成员的声明> };<成员函数的实现> 若在类体外实现，则需要使用作用域运算符“::”，用它来标识某个成员函数是属于哪个类的，其定义格式如下：
<函数值类型><类名>::<成员函数名>(<参数表>){ <函数体> } 类外访问对象中的成员可以有3种方法： 通过对象名和成员运算符访问对象中的成员。<对象名>.<公有成员> 通过指向对象的指针变量访问对象中的成员。<对象指针名>-><公有成员> 通过对象的引用访问对象中的成员。析构函数其定义格式如下： <类名>::~<类名>(){
<函数体> } 在一般情况下，调用构造函数与声明对象的顺序相同，而调用析构函数的次序正好与创建对象的顺序相反。三种构造函数
Box();
//无参构造函数 Box(int h,int w ,int len):height(h),width(w),length(len){}
//带参构造函数 复制构造函数定义
<类名>(<参数表>);
<类名>(const <类名>&<对象名>)Box(const Box& b);//复制构造函数
复制构造函数只有一个参数，并且是对同类对象的引用。
静态成员是类的所有对象共享的成员，而不是某个对象的成员，它在对象中不占存储空间，是属于整个类的成员。静态成员定义格式如下： static <静态成员的定义>;不能用参数初始化表对静态数据成员初始化，也不能在构造函数体内初始化，静态数据成员只能在类体外进行初始化。静态数据成员初始化格式如下：
<数据类型><类名>::<静态数据成员名>=<值>;在类的成员函数中可以直接访问该类的静态数据成员，而不必使用成员访问运算符或类名限定修饰符。
在类外必须使用成员访问运算符或类名限定修饰符访问公共静态数据成员。<对象名>.<静态成员> <类名>::<静态成员> 静态成员函数就是使用static关键字声明的成员函数。
静态成员函数可以直接访问该类的静态成员，但不能直接访问类中的非静态成员。
第3章 详解对象
对象指针就是用于存放对象数据起始地址的变量。声明对象指针的一般格式为： <类名> *<对象指针名>;对象指针的初始化一般格式为： <数据类型> *<对象指针名>=&<对象名>;<对象指针名>=&<对象名>;通过指针访问对象成员一般格式如下： <对象指针名>-><公有成员>
boxp->volumn();(*<对象指针名>).<公有成员>
(*boxp).volumn();this指针是一个特殊的隐含指针，它隐含于每一个成员函数（静态成员函数除外）中，也就是说，每个成员函数都有一个this指针参数。
this指针指向调用该函数的对象，即this指针的值是当前被调用的成员函数所在的对象的起始地址。
复制构造函数中隐含使用this指针： TAdd(const TAdd& p){
this->x=p.x;this->y=p.y;
cout<<“copy constructor.”< x this->x (*this).x this指针是一个const指针，成员函数不能对其进行赋值。 静态成员中不能访问this指针，因为静态成员函数不从属于任何对象。指向非静态数据成员的指针一般形式为： 数据类型名 *指针变量名； 定义指向公有成员函数的指针变量的一般形式为： 数据类型名(类名:: *指针变量名)(参数列表)； 使指针变量指向一个公有成员函数的一般形式为： 指针变量名=&类名::成员函数名 常量定义格式如下： const <数据类型名><常量名>=<表达式>;常对象是其数据成员值在对象的整个生存期间内不能被改变的对象。const <类名> <对象名>(<初始化值>);<类名> const <对象名>(<初始化值>);常成员函数 通过常成员函数来引用本类中的常数据成员。<数据类型><函数名>(<参数表>)const; 声明一维对象数组的一般格式为： <类名><数组名>[<下标表达式>] 6 第4章 运算符重载 重载为类的成员函数格式如下： <类名> operator <运算符>(<参数表>){ 函数体 } A operator +(A &);++为前置运算符时，它的运算符重载函数的一般格式为： 运算符重载函数不能定义为静态的成员函数，因为静态的成员函数中没有this指针。 友元声明以关键字friend开始，只能出现在被访问类的定义中。具体格式如下： friend <函数值类型><函数名>(<参数表>);friend class <类名>; 友元函数可以访问该类中的所有成员（公有的、私有的和保护的） 通常使用友元函数来取对象中的数据成员值，而不修改对象中的成员值，保证数据安全。 重载为类的友元函数语法形式 friend <函数值类型> operator <运算符>(<参数表>){<函数体>；} ++为前置运算符时，它的运算符重载函数的一般格式为： A operator ++(A &a)++为后置运算符时，它的运算符重载函数的一般格式为： A operator ++(A &a, int) 重载提取运算符的一般格式为： friend istream & operater >>(istream &, ClassName &);istream & operater >>(istream &is, ClassName &f){„} 重载输出（插入）运算符的一般格式为： friend ostream & operater >>(ostream &, ClassName &);ostream & operater >>(ostream &is, ClassName &f){„} 重载类型转换运算符函数格式： operator〈返回基本类型名〉（）{ „„ return 〈基本类型值〉 } 类类型转换函数只能是成员函数，不能是友元函数。转换函数的操作数是对象。8 第5章 继承与派生 派生是指由基类创建新类的过程。class A { int i;//基类成员};class B:public A //A派生了B，B继承了A，//B自动拥有A的成员 {int j;//定义派生类的新成员};派生类的定义格式如下： class <派生类名>:<继承方式><基类名> { <派生类新定义成员>};派生类继承了基类的全部数据成员和除了构造、析构函数之外的全部成员函数，它们在派生类中的访问属性由继承方式控制。三种继承方式下派生类中基类成员的访问控制权限 无论是哪种继承方式，基类的私有成员在派生类中都是不可被访问的。只能通过基类的成员函数访问基类的私有数据成员。 解决的办法是通过成员初始化表来完成，在成员初始化表中可以显式调用基类构造函数。 <派生类名>(<总参数表>):<基类名>(<参数表1>),<对象成员名>(<参数表2>){ <派生类数据成员的初始化> };构造函数调用顺序为：基类的构造函数→对象成员构造函数→派生类的构造函数。 析构函数调用顺序刚好相反。当基类中没有显式定义构造函数，或定义了无参构造函数时，派生类构造函数的初始化表可以省略对基类构造函数的调用，而采用隐含调用。当基类的构造函数使用一个或多个参数时，派生类必须定义构造函数，提供将参数传递给基类构造函数的途径。这时，派生类构造函数的函数体可能为空，仅起到参数传递作用。 如果在基类中既定义了无参构造函数，又定义了带参构造函数，则在定义派生类构造函数时，既可以包含基类构造函数和参数，也可以不包含基类构造函数。如果在一个派生类中要访问基类中的私有成员，可以将这个派生类声明为基类的友元。 友元关系是不能继承的。B类是A类的友元，C类是B类的派生类，则C类和A类之间没有任何友元关系，除非C类声明A类是友元。多继承派生类的定义 class <派生类名>:<继承方式><基类名1>，„，<继承方式><基类名n> {<派生类新定义成员>};多继承派生类的构造函数 <派生类名>(<总参数表>):<基类名1>(<参数表1>)，„，< 基类名n>(<参数表n>){ <派生类数据成员的初始化> };<总参数表>必须包含完成所有基类初始化所需的参数 构造函数调用顺序是：先调用所有基类的构造函数，再调用对象成员类构造函数，最后调用派生类的构造函数。 处于同一层次的各基类构造函数的调用顺序取决于定义派生类时所指定的基类顺序，与派生类构造函数中所定义的成员初始化列表顺序无关。如果有多个成员类对象，则构造函数的调用顺序是对象在类中被声明的顺序，而不是它们出现在成员初始化表中的顺序。 析构函数的调用顺序与构造函数的调用顺序相反。虚基类 虚基类的定义格式为： class <派生类名>:virtual <继承方式><共同基类名>;【说明】引进虚基类后，派生类对象中只存在一个虚基类成员的副本。虚基类的初始化与一般多继承的初始化在语法上相同，但构造函数的调用顺序有所不同，规则如下： 先调用虚基类的构造函数，再调用非虚基类的构造函数。若同一层次中包含多个虚基类，其调用顺序为定义时的顺序。若虚基类由非虚基类派生而来，则仍按先调用基类构造函数，再调用派生类构造函数的顺序。 如果在虚基类中定义了带参数的构造函数，则要在其所有派生类（包括直接派生类或间接派生类）中，通过构造函数的初始化表对虚基类进行初始化。 第6章 多态性与虚函数 类型兼容规则 类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。 类型兼容规则中所指的替代包括以下情况： 派生类的对象可以赋值给基类的对象。派生类的对象可以初始化基类的引用。 派生类的对象的地址可以赋值给基类的指针变量。在替代之后，派生类对象就可以作为基类的对象使用，但只能访问从基类继承的成员。 只能用派生类对象对其基类对象赋值，而不能用基类对象对其派生类对象赋值。同一基类的不同派生类对象之间也不能赋值。虚函数 虚函数就是在基类中被关键字virtual说明、并在一个或多个派生类中被重新定义的成员函数。 声明虚函数的格式如下： virtual <函数值类型><函数名>(<参数表>);在派生类中重新定义虚函数时，其函数原型包括返回类型、函数名、参数个数、类型和顺序，都必须与基类中的原型相同。一个函数一旦被声明为虚函数，则无论声明它的类被继承了多少层，在每一层派生类中该函数都保持虚函数特性。因此，在派生类中重新定义该函数时，可以省略关键字virtual。实现动态的多态性时，必须使用基类类型的指针变量或对象引用，并使其指向不同的派生类对象，并通过调用指针或引用所指向的虚函数才能实现动态的多态性。可将类簇中具有共性的成员函数声明为虚函数，而具有个性的函数没有必要声明为虚函数。但是下面的情况例外： 静态成员函数不能声明为虚函数。构造函数不能是虚函数。 内联成员函数不能声明为虚函数。析构函数可以是虚函数。虚析构函数 虚析构函数的声明格式如下： virtual ~<类名>();如果一个类的析构函数是虚函数，那么，由它派生的所有子类的析构函数也是虚函数。 纯虚函数用virtual声明，没有任何实现、必须由派生类覆盖该函数提供实现 纯虚函数的声明格式为： virtual <函数值类型><函数名>(<参数表>)=0;包含一个或多个纯虚函数的类称为抽象类。 如果派生类没有实现基类中的所有纯虚函数，派生类也是抽象类。抽象类无法实例化，即不能创建抽象类的对象。第7章 输入输出 iostream:I/O流类库的最主要的头文件，包含了对输入输出流进行操作所需的基本信息，还包括cin、cout、cerr和clog共4个流对象。fstream:用于用户管理的文件的I/O操作。strstream:用于字符串流I/O。 stdiostream:用于混合使用C和C++的I/O操作。iomanip:使用格式化I/O时应包含此头文件。 用setf函数设置状态标志，其一般格式如下： long ios::setf(long flags)清除状态标志 用unsetf函数清除状态标志，其一般格式如下： long ios::unsetf(long flags)用函数flags取状态标志有两种形式，其格式分别如下： long ios::flags() //返回与流相关的当前状态标志值 long ios::flags(long flag)//将流的状态标志值设置为flag，并返回设置前的状态标志值。以上三组函数必须用流类对象（cin或cout）来调用，其格式如下： <流对象名>.<函数名>(ios::<状态标志>)cout.setf(ios::showpos);cout.setf(ios::scientific);cout.setf(ios::showpos| ios::scientific);设置输出宽度函数有两种形式，其格式分别如下： int ios::width(int len) int ios::width()第一种形式是设置输出宽度，并返回原来的输出宽度； 第二种形式是返回当前输出宽度，默认输出宽度为0。只对其后的第一个输出项有效。 填充字符的作用是当输出值不满输出宽度时用填充字符来填充，默认填充字符为空格。它与width()函数配合使用，否则没有意义。设置填充字符函数有两种形式，其格式分别如下： char ios::fill(char ch) char ios::fill()第一种形式是重新设置填充字符，并返回设置前的填充字符； 第二种形式是返回当前的填充字符。 设置浮点数输出精度有两种形式，其格式分别如下： int ios::precision(int p) int ios::precision()第一种形式是重新设置输出精度，并返回设置前的输出精度； 第二种形式是返回当前的输出精度。默认输出精度为6 用get函数读入一个字符(1)不带参数的get函数 cin.get()用来从指定的输入流中提取一个字符（包括空白字符），函数的返回值就是读入的字符。 若遇到输入流中的文件结束符，则函数返回文件结束标志EOF。(2)有一个参数的get函数 cin.get(ch)用来从输入流中读取一个字符，赋给字符变量ch。读取成功返回非0值（真），如失败（遇文件结束符）则函数返回0值（假）。3)有三个参数的get函数 cin.get(字符数组/字符指针，字符个数n，终止字符)从输入流中读取n-1个字符，赋给指定的字符数组（或字符指针指向的数组）。如果在读取n-1个字符之前遇到指定的终止字符，则提前读取结束。如果读取成功返回非0值（真），如失败（遇文件结束符）则函数返回0值（假）。用getline函数读入一行字符 cin.getline(字符数组（或字符指针），字符个数n，终止字符)从输入流中读取一行字符，其用法与带3个参数的get函数类似。eof函数 无参函数，表示文件结束。 从输入流读取数据，如果到达文件末尾（遇文件结束符），返回非零值（真），否则为0（假）。 while（！cin.eof（））peek函数 无参函数，表示“观察”，观测下一个字符。 返回值是当前指针指向的当前字符，但只是观测，指针仍停留在当前位置，并不后移。 如果要访问的字符是文件结束符，则函数值是EOF。 c=cin.peek（）； putback函数 将前面用get或getline函数从输入流中读取的字符ch返回到输入流，插入到当前指针位置，以供后面读取。 控制符不属于任何类成员，定义在iomanip头文件中 设置输入/输出宽度setw(int)用整型参数来制定输入/输出域的宽度。使用时只对其后一项输入/输出有效。当用于输出时，若实际宽度小于设置宽度时，数据向右对齐，反之则按数据的实际宽度输出。 当用于输入时，若输入的数据宽度超过设置宽度时，超出的数据部分被截断而被作为下一项输入内容。 设置输出填充字符setfill(char)与ios::fill相同，常与setw(int)联合使用，从而向不满设置输出宽度的空间填入指定的字符，不设置则填空格。设置后直至下一次设置前一直有效。参数可以是字符常量或字符变量。 设置输出精度setprecision(int)指明输出实数的有效位数。 参数为0时，按默认有效位数6输出。 在以fixed形式和scientific形式输出时参数为小数位数。 setiosflags(ios::fixed)用定点方式表示实数。 setiosflags(ios::scientific)用科学记数法方式表示实数。 如果setprecision(n)与setiosflags(ios::fixed)合用，可以控制小数点右边的数字个数。 如果setprecision(n)与setiosflags(ios::scientific)合用，可以控制科学记数法中尾数的小数位数。 setiosflags(ios::left)输出数据左对齐 setiosflags(ios::right)输出数据右对齐 设置输入/输出整型数数制dec、hex和oct。控制换行的控制符endl 代表输出单字符“ ”的控制符ends open()函数的原型在fstream中定义。其原型为： void open(char *filename,int mod,int access);其中第一个参数是用来传递文件名；第二个参数的值决定文件的使用方式；第三个参数的值决定文件的访问方式。 对于ifstream流类，mod的值为ios::in;对于ofstream流类，mod的值为ios::out 《面向对象程序设计》课程教案 课程编号：08051230 课程名称：面向对象程序设计（Object-oriented Programming）学时：72学时，其中理论学时54，上机学时18 学分：3.5开课部门：数学与计算机科学学院 开课教研室：计算机科学 开课教师：雷小园 开课学期：第7学期 授课班级：04信计 先修课程：C语言程序设计 考核要求：考试，平时10％，实验20％，考试70％ 使用教材： 《C++面向对象程序设计教程(第2版)》，陈维兴，清华大学出版社，2004年 《C++面向对象程序设计习题解答与实验指导》，陈维兴，清华大学出版社，2004年 教学目的与要求： 《面向对象程序设计》是一门计算机及相关专业的重要的专业基础课。本课程讲述C++语言面向对象的基本特性，包括类、对象、派生类、继承、运算符重载、多态性、虚函数、函数模板、类模板、输入输出、流类库、文件等，使学生掌握面向对象程序设计的基本概念和基本方法，能运用C++语言进行基本的面向对象程序设计。 教学方法： 采用板书讲解C++程序设计，再加以上机练习C++编程。 3章 类和对象 3.1 类与对象的基本概念 3.2 构造函数与析构函数 例：点类 Point class Point { private: int x,y;public: Point(){};Point(int xx, int yy){ x=xx;y=yy;} Point(Point &p){ x=p.x;y=p.y;} int GetX()const { return x;} int GetY()const { return y;} void SetXY(int xx, int yy){ x=xx;y=yy;} void Show();};void Point::Show(){ cout<<“X: ”< 例：人类 Person class Person { protected: char *name;int age;char sex;public: Person(char *n, int a, char s);Person(){ name = 0;age = 0;sex = ' ';} Person(Person &p);~Person(){ delete[] name;} void SetName(char *n);void SetAge(int a){ age = a;} void SetSex(int s){ sex = s;} char *GetName()const { return name;} int GetAge()const { return age;} char GetSex()const { return sex;} void Show();}; #include “person.h” #include Person::Person(char *n, int a, char s){ name = new char[strlen(n)+1];strcpy(name,n);age = a;sex = s;} Person::Person(Person &p){ name = new char[strlen(p.name)+1];strcpy(name,p.name);age = p.age;sex = p.sex;} void Person::SetName(char *n){ delete[] name;name = new char[strlen(n)+1];strcpy(name,n);} void Person::Show(){ cout<<“Name: ”< 1、对象数组 所谓对象数组是指每一数组元素都是对象的数组。 2、对象指针 声明对象指针的一般语法形式为：类名* 对象指针名。当用指向对象的指针来访问对象成员时，要用“->”操作符。 3、this指针 C++为成员函数提供了一个名字为this的指针，这个指针称为自引用指针。每当通过一个对象调用一个成员函数时，系统就自动把这个this指针指向该对象。因此使用的数据成员就是该对象的数据成员。 3.4 向函数传递对象 1、使用对象作为函数参数 2、使用对象指针作为函数参数 3、使用对象引用作为函数参数 3.5 静态成员 1、静态数据成员 在一个类中,若将一个数据成员说明为static,这种成员称为静态数据成员。与一般的数据成员不同,无论建立多少个类的对象,都只有一个静态数据的拷贝。从而实现了同一个类的不同对象之间的数据共享。 定义静态数据成员的格式如下: static 数据类型 数据成员名;静态数据成员在该类定义之外被初始化。访问静态数据成员可以通过对象或指针来访问，也可以通过类名::来访问。 2、静态成员函数 定义静态成员函数的格式如下: static 返回类型 静态成员函数名（参数表）;与静态数据成员类似,调用公有静态成员函数的一般格式有如下几种: 类名::静态成员函数名(实参表)对象.静态成员函数名(实参表)对象指针->静态成员函数名(实参表) 例：点类 Point（演示静态成员）class Point { private: int x,y;static int count;public: Point(int xx=0, int yy=0){ x=xx;y=yy;count++;} Point(Point &p){ x=p.x;y=p.y;count++;} int GetX()const { return x;} int GetY()const { return y;} void SetXY(int xx, int yy){ x=xx;y=yy;} static int GetCount(){ return count;} }; int Point::count=0; int main(){ Point a(100,200), b;cout< 1、友元函数 友元函数不是当前类的成员函数,而是独立于当前类的外部函数,但它可以访问该类的所有对象的成员,包括私有成员、保护成员和公有成员。 2、友元成员 一个类的成员函数也可以作为另一个类的友元,这种成员函数不仅可以访问自己所在类对象中的所有成员,还可以访问friend声明语句所在类对象中的所有成员。 3、友元类 一个类也可以作为另一个类的友元。 友元关系是单向的，不具有交换性。若类X是类Y的友元，类Y不一定是类X的友元。友元关系也不具有传递性。若类X是类Y的友元，Y是类Z的友元，类X不一定是类Z的友元。 例：点类 Point（演示友元）class Point { private: int x,y;static int count;public: Point(int xx=0, int yy=0){ x=xx;y=yy;} int GetX()const { return x;} int GetY()const { return y;} void SetXY(int xx, int yy){ x=xx;y=yy;} friend double Dist(Point p1, Point p2);}; friend double Dist(Point p1, Point p2);{ double x,y;x=p1.x-p2.x;y=p1.y-p2.y;return sqrt(x*x+y*y);} int main(){ Point a(100,200), b(300,400);cout<<“两点间的距离为：”< 例：圆类 Circle（包含Point类的写法）class Circle { private: double radius;//半径 Point center;//圆心 public: Circle(){} Circle(int x, int y, double r): center(x,y){ SetRadius(r);} Circle(Point p, double r): center(p){ SetRadius(r);} double GetRadius()const { return radius;} void SetRadius(double r){ radius =(r>=0 ? r : 0);} void SetValue(int x, int y, double r){ center.SetXY(x,y);SetRadius(r);} double Area();void Show();}; const double PI=3.14159;inline double Circle::Area(){ return PI * radius * radius;} void Circle::Show(){ cout<<“圆心为: ” center.Show();cout<<“半径为: ”< 1、const引用 const引用的说明形式如下: const 类型说明符& 引用名 2、const对象 const对象的说明形式如下: const 类名 对象名[(参数表)];如：const Data Mybirthday(1980,1,1);const对象的数据成员值不能被改变，const对象必须进行初始化。通过const对象只能调用它的const成员函数，而不能调用普通成员函数。 3、const数据成员 const数据成员只能通过构造函数的初始化列表来获得初始值。 4、const成员函数 const成员函数的说明格式如下: 类型说明符 函数名(参数表)const;如：int GetYear()const { return year;} const成员函数不能更新对象的数据成员，也不能调用对象的普通成员函数。const是函数类型的一个组成部分,因此在函数的实现部分也要带关键字const。 5、引用类型的数据成员 引用类型的数据成员也只能通过构造函数的初始化列表来进行初始化。 例 class Test { private: int a;const int b;//不能写成const int b=10，因类的定义还没分配空间 int &c;//不能写成const int &c=a，因变量a还没分配空间 public: Test(int i,int j,int &k):b(j),c(k){ a=i;} Test():b(10),c(a){ a=20;} } 第4章 派生类与继承 4.1 派生类的概念 4.2 派生类的构造函数与析构函数 例：圆类 Circle（继承Point类的写法）class Circle: public Point { private: double radius;//半径 public: Circle(){} Circle(int x, int y, double r): Point(x,y){ SetRadius(r);} Circle(Point p, double r): Point(p){ SetRadius(r);} double GetRadius()const { return radius;} void SetRadius(double r){ radius =(r>=0 ? r : 0);} void SetValue(int x, int y, double r){ SetXY(x,y);SetRadius(r);} double Area();void Show();}; const double PI=3.14159;inline double Circle::Area(){ return PI * radius * radius;} void Circle::Show(){ cout<<“圆心为: ” Point::Show();cout<<“半径为: ”< 1、派生类继承了它的所有基类中除构造函数和析构函数之外的所有成员。 2、在派生类中成员按访问属性划分为四种：不可访问的成员、私有成员、保护成员、公有成员。 3、对从基类继承下来的成员初始化工作是通过调用基类的构造函数来完成的，调用方法是在派生类的构造函数中用初始化列表。 4、如果在派生类的构造函数省略了基类的初始化列表，则将调用基类的缺省构造函数。 5、如果基类定义了带有参数的构造函数时，派生类就应当定义构造函数，以便显式地调用基类的构造函数。 6、如果派生类定义了与基类同名的新数据成员或成员函数，则此派生类的成员就覆盖了基类的同名成员，直接使用成员名只能访问到派生类的成员。 7、在同名覆盖的情况下，可以使用基类名+作用域分辨符来访问基类的同名成员。 8、如果派生类和基类的某个成员函数重名，但参数表不同，仍然属于覆盖，不属于重载。 9、对派生类的对象，构造函数的执行过程是：先调用基类的构造函数（按它们被继承时声明的顺序），再调用内嵌对象成员的构造函数（按内嵌对象声明的顺序），最后执行自己的构造函数体中的内容。 10、析构函数的调用次序正好和构造函数的调用次序相反。 例：学生类 Student //student.h #include “person.h” class Student: public Person { protected: char *Department;int Number;public: Student(){ Department = 0;Number = 0;} Student(char *, int, char, char *, int);Student(Student &stu);~Student(){ delete[] Department;} void SetDep(char*);void SetNum(int num){ Number = num;} char *GetDep()const { return Department;} int GetNum()const { return Number;} void Show();}; //student.cpp #include “student.h” #include Student::Student(char *name,int age,char sex,char *dep,int num): Person(name, age, sex){ Department = new char[strlen(dep)+1];strcpy(Department, dep);Number = num;} Student::Student(Student &stu): Person(stu){ Department = new char[strlen(stu.Department)+1];strcpy(Department, stu.Department);Number = stu.Number;} void Student::SetDep(char *dep){ delete[] Department;Department = new char[strlen(dep)+1];strcpy(Department, dep);} void Student::Show(){ Person::Show();cout<<“Department: ” < 4.4 多重继承 例1：X和Y是基类，Z从X和Y派生 class X { public: int b;X(int k){ b=k;} };class Y { public: int c;Y(int k){ c=k;} };class Z: public X, public Y { public: int d;Z(int i,int j,int k):X(i),Y(j){ d=k;} } 例2：X和Y都从W派生而来 class W { public: int a;W(int k){ d=k;} };class X: public W { public: int b;X(int i, int k): W(i){ b=k;} };class Y: public W { public: int c;Y(int i, int k): W(i){ c=k;} };class Z: public X, public Y { public: int d;Z(int i, int j, int k, int l): X(i,j),Y(i,k){ d=l;} } int main(){ Z t(10,20,30,40);cout< 例3：将W做为X和Y的虚基类 class W { public: int a;W(int k){ a=k;} };class X: virtual public W { public: int b;X(int i, int k): W(i){ b=k;} };class Y: virtual public W { public: int c;Y(int i, int k): W(i){ c=k;} };class Z: public X, public Y { public: int d;Z(int i, int j, int k, int l): W(i),X(i,j),Y(i,k){ d=l;} } int main(){ Z t(10,20,30,40);cout< (2)建立一个对象时,如果这个对象中含有从虚基类继承来的成员,则虚基类的成员是由最远派生类的构造函数通过调用虚基类的构造函数进行初始化的。该派生类的其他基类对虚基类构造函数的调用都自动被忽略。 (3)若同一层次中同时包含虚基类和非虚基类,应先调用虚基类的构造函数,再调用非虚基类的构造函数,最后调用派生类构造函数;(4)对于多个虚基类,构造函数的执行顺序仍然是先左后右,自上而下;(5)对于非虚基类,构造函数的执行顺序仍是先左后右,自上而下;(6)若虚基类由非虚基类派生而来,则仍然先调用基类构造函数,再调用派生类的构造函数。 4.5 赋值兼容规则 所谓赋值兼容规则是指在需要基类对象的任何地方都可以使用公有派生类的对象来替代。 附：线性表——顺序表 class SeqList { private: int *data;int size;int MaxSize;public: SeqList(int sz=100);~SeqList(){ delete []data;} int Length()const { return size;} bool IsEmpty()const { return size==0;} void Insert(const int &x, int k);void Delete(int k);int GetData(int k)const;int Find(const int &x)const;void Show()const;};SeqList::SeqList(int sz){ MaxSize=sz;data=new int[MaxSize];size=0;} void SeqList::Insert(const int &x, int k){ if(k<1 || k>size+1){ cerr<<“越界出错”;exit(1);} if(size==MaxSize){ cerr<<“顺序表已满”;exit(1);} for(int i=size-1;i>=k-1;i--)data[i+1]=data[i];data[k-1]=x;size++;} void SeqList::Delete(int k){ if(size==0){ cerr<<“顺序表空”;exit(1);} if(k<1 || k>size){ cerr<<“越界出错”;exit(1);} for(int i=k;i int SeqList::GetData(int k)const { if(k<1 || k>size){ cerr<<“越界出错”;exit(1);} return data[k-1];} int SeqList::Find(const int &x)const { for(int i=0;i void SeqList::Show()const { for(int i=0;i 第5章 多态性 5.1 编译时的多态性与运行时的多态性 5.2 函数重载 5.3 运算符重载 例：复数类Complex //mycomplex.h #include #include“mycomplex.h” #include Complex &Complex::operator+=(Complex &c){ re += c.re;im += c.im;return *this;} Complex &Complex::operator-=(Complex &c){ re-= c.re;im-= c.im;return *this;} Complex &Complex::operator*=(Complex &c){ double t = re * c.rere * c.im)/ m;re = t;return *this;} Complex operator+(Complex &a, Complex &b){ return Complex(a.re + b.re, a.im + b.im);} Complex operator-(Complex &a, Complex &b){ return Complex(a.reb.im);} Complex operator*(Complex &a, Complex &b){ return Complex(a.re * b.rea.re * b.im)/ m);} bool operator==(Complex &a, Complex &b){ return a.re == b.re && a.im == b.im;} bool operator!=(Complex &a, Complex &b){ return a.re!= b.re || a.im!= b.im;} ostream &operator<<(ostream &os, Complex &c){ os << c.re << '+' << c.im << 'i';return os;} istream &operator>>(istream &is, Complex &c){ is >> c.re >> c.im;return is;} 例：分数类 Fraction #include class Fraction { private: int num, den;void reduce();public: Fraction(int n=0, int d=1);Fraction operator+(){ return *this;} Fraction operator-(){ return Fraction(-num, den);} Fraction &operator+=(Fraction &);Fraction &operator-=(Fraction &);Fraction &operator*=(Fraction &);Fraction &operator/=(Fraction &);Fraction &operator++();Fraction operator++(int);operator double();friend Fraction operator+(Fraction &, Fraction &);friend Fraction operator-(Fraction &, Fraction &);friend Fraction operator*(Fraction &, Fraction &);friend Fraction operator/(Fraction &, Fraction &);friend bool operator==(Fraction &, Fraction &);friend bool operator!=(Fraction &, Fraction &);friend bool operator<(Fraction &, Fraction &);friend bool operator<=(Fraction &, Fraction &);friend bool operator>(Fraction &, Fraction &);friend bool operator>=(Fraction &, Fraction &);friend ostream &operator<<(ostream &, Fraction &);friend istream &operator>>(istream &, Fraction &);};#include “fraction.h” #include 5.4 类型转换 1、通过构造函数将别的类型转换为这个类的类型 如复数Complex类的构造函数 Complex(double r){ re=r;} 2、通过转换函数讲这个类的类型转换为别的类型 如在复数Complex类中的转换函数 operator double(){ return re;} 在分数Fraction类中的转换函数 operator double(){ return static_cast 用explicit关键字，可以禁止单个参数的构造函数用于自动类型转换，如 class Stack { explicit Stack(int size);„ „ } Explicit也同样禁止用赋值来进行带有类型转换的初始化行为 如，不可以 Stack s=10;5.5 虚函数 1、引入派生类后的对象指针 例： class A { public: void show(){ cout<<“A”;} };class B:public A { public: void show(){ cout<<“B”;} };int main(){ A a,*pc;B b;pc=&a;pc->show();pc=&b;pc->show();} 输出为AA 2、虚函数的定义及使用 例：引入虚函数后，上面的例子改为如下 class A { public: virtual void show(){ cout<<“A”;} };class B:public A { public: void show(){ cout<<“B”;} };int main(){ A a,*pc;B b;pc=&a;pc->show();pc=&b;pc->show();} 输出为AB 3、纯虚函数和抽象类 例： class A { public: virtual void show()=0;};class B:public A { public: void show(){ cout<<“B”;} };int main(){ A *pc;B b;pc=&b;pc->show();} 关于虚函数，有以下几点 1、如果成员函数是通过引用或指针，而不是通过对象来调用，那么，如果没有使用virtual，程序将根据引用类型或指针类型来选择方法；如果使用了virtual，程序将根据引用或指针指向的对象的类型来选择方法。 2、如果要在派生类中重新定义基类的方法，则将它设置为虚拟方法，否则是指为非虚拟方法 3、如果使用指向对象的引用或指针来调用虚拟方法，程序将使用为对象类型定义的方法，而不使用为引用类型或指针类型定义的方法，这称为动态联编或晚期联编。 4、在基类方法的声明中使用virtual可使该方法在基类以及所有的派生类中都是虚拟的。 5、一个未在派生类中定义的纯虚函数仍旧还是一个纯虚函数，该派生类仍为一个抽象类。 6、通常应给基类提供一个虚拟析构函数，这样，当派生类对象结束时，将先调用派生的析构函数，再调用基类的析构函数。 7、如果派生类没有重新定义虚拟函数，则将使用该函数的基类版本。 8、如果重新定义继承的方法，应确保与原来的原型完全相同。但有一个例外，就是如果返回类型是基类指针或引用，则可改为指向派生类的指针或引用。实验 基本C++程序设计 2 类和对象程序设计 3 派生与继承程序设计 4 运算符重载程序设计 5 模板程序设计 6 I/ O 流程序设计 《面向对象程序设计》实验教学大纲 课程总学时：64 学分：4 实验学时：16 实验个数： 6个实验学分：1分 课程性质：专业必修课适用专业：计算机类专业 教材及参考书：《C++语言程序设计（第四版）》，郑莉、董渊编著，北京：清华大学出版社，2011 大纲执笔人：杨军 大纲审定人： 一、实验课的性质与任务 本课程实验大纲是面向计算机专业学生开设的《C++程序设计》实验课计划指导大纲，是依据《面向对象程序设计》课程教学计划指导大纲编制。本课程主要讲述了利用C++进行程序设计的思想和方法，既有面向过程和面向对象的程序设计的理论知识，又包括极强的实践应用能力的培养。本实验大纲力求结合该课程教学计划大纲的相应内容，由浅入深的指导学生了解和掌握如何利用C++程序设计语言进行程序设计，提高学生的动手能力，做到理论和实践相结合，培养学生理解，分析程序，编写，调试程序的能力，使之能把程序设计应用到今后的专业学习中。 二、实验目的与要求 1．实验目的 通过本课程的学习，使学生掌握面向过程的程序设计思想和编程思路，初步掌握面向对象的程序设计思想，学会调试程序，能独立编写实用的小型程序。2．实验要求 学生应该自始至终贯彻课程中所介绍的程序设计风格,养成良好的编程习惯； 应独立完成所布置习题。为保证尽量在统一安排的上机时间内编译运行通过程序，学生应事先设计好程序。 三、实验项目及内容提要 面向对象程序设计实验课程（071016） 序号 实验编号 实验名称 学时 必做 选做 学分数 实验类型 内容提要 基本操作 验证 综合设计 1 类与对象 √ √ 函数重载,类的设计与使用 2 2 C++程序的结构 √ √ 作用域与生存期，静态成员 3 数组、指针与字符串 √ √ 三种常见编程元素的使用 4 继承与派生 √ √ 派生类的设计与使用 5 多态性 √ √ 运算符重载、动态多态 6 模板和文件 √ √ 模板，异常处理机制的设计 四、实验内容安排： 实验一类与对象 （设计性实验 4学时）目的要求： 掌握类的定义和使用；掌握类对象的声明；练习具有不同访问属性的成员的访问方式；观察构造函数和析构函数的执行过程； 学习类组合使用方法； 使用VC++的debug调试功能观察程序流程，跟踪观察类的构造函数、析构函数、成员函数的执行顺序。实验内容： 编写重载函数Max1可分别求取两个整数，三个整数，两个双精度数，三个双精度数的最大值。 写一个函数，具有一个引用作为形参参数，在函数中改变引用变量的值，观察实参变量的变化。 定义一个CPU类，包含等级（Rank）、频率（frequency）、电压(voltage)等属性，有两个公有成员函数run、stop。其中，rank为枚举类型CPU__Rank,定义为enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7},frequency为单位是MHz的整型数，voltage为浮点型的电压值。观察构造函数和析构函数的调用顺序。定义一个简单的Computer类，有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等，有两个公有成员函数run、stop。cpu为CPU类的一个对象，ram为RAM类的一个对象，cdrom为CDROM类的一个对象，定义并实现这个类，为以上的类编写构造和析构函数，观察组合类和内嵌类的构造函数和析构函数的调用顺序。 为题目2）的类编写复制构造函数，在主函数中利用复制构造的方式创建新的对象，观察对象的状态。 思考并回答以下概念：函数重载，引用，类，对象，数据成员，函数成员，访问属性，构造函数，析构函数，类的组合，内嵌对象，初始化列表，复制构造函数。主要仪器设备及软件：PC+Windows 2000+VC 6.0 实验二 C++程序的结构（设计性实验 2学时）目的要求： 观察程序运行中变量的作用域、生存期和可见性； 学习类的静态成员的使用； 学习多文件结构在C++程序中的使用。实验内容： 实现客户机(CLIENT)类。定义字符型静态数据成员ServerName，保存其服务器名称；整型静态数据成员ClientNum，记录已定义的客户数量；定义静态函数ChangeServerName()改变服务器名称。 利用多文件结构实现题目1），在头文件client.h中定义类，在文件client.cpp中实现该类，在文件test.cpp 中测试这个类，观察相应的成员变量取值的变化情况，要求ClientNum能够实时记录客户机对象的数量。 思考并回答以下概念：类的静态数据成员，类的静态函数成员，多文件结构，文件包含。主要仪器设备及软件：Windows 2000+VC 6.0 实验三数组、指针与字符串实验（设计性实验 4学时）目的要求： 学习使用数组；学习字符串数据的组织和处理；学习标准C++库的使用； 掌握指针的使用方法；练习通过debug观察指针的内容及其所指的对象的内容；练习通过动态内存分配实现动态数组，并体会指针在其中的作用； 分别使用字符数组和标准C++库练习处理字符串的方法。实验内容： 编写一个类用于处理3×3矩阵转置，测试转置的效果，输出转置前后的矩阵。 定义一个具有构造函数和析构函数的类，如实验一的CPU类，定义一个CPU的对象数组，观察构造函数的析构函数的调用过程。利用动态内存分配的方式重新完成题目2）。 使用系统提供的string类定义字符串对象并初始化，实现从原始字符串中提取一个子串。选做：定义一个Point（二维点类）的对象数组，利用该数组实现直线的线性拟合。选做：定义一个动态数组类。 思考并回答：数组，指针，对象数组，动态内存分配，默认构造函数，标准类库，字符串类 string，线性拟合。 3.主要仪器设备及软件：Windows 2000+VC 6.0 实验四继承与派生 （设计性实验 2学时）目的要求： 学习定义和使用类的继承关系，定义派生类；熟悉不同继承方式下对基类成员的访问控制； 学习利用虚基类解决二义性问题。实验内容： 定义一个基类Animal，有私有整型成员变量age，构造其派生类dog，在其成员函数SetAge(int n)中直接给age赋值，看看会有什么问题，把 age改为公有成员变量，还会有问题吗？编程试试看。 定义一个基类BaseClass,有整型成员变量Number，构造其派生类DerivedClass,定义该派生类的对象,观察构造函数和析构函数的执行情况。 定义一个车（vehicle）基类，具有MaxSpeed、Weight等成员变量，Run、Stop等成员函数，由此派生出自行车（bicycle）类，汽车（motorcar）类。自行车（bicycle）类有高度（Height）等属性，汽车（motorcycle）类有座位数（SeatNum）等属性。从bicycle和motorcycle派生出摩托车(Motorcar)类，在继承过程中，注意把vehicle设置为虚基类。如果不把vehicle 设置为虚基类，会有什么问？编程实验及分析原因。 思考并回答：继承，派生，子类对基类成员的访问权限，继承方式，继承时的构造函数和析构函数的调用顺序，虚基类 主要仪器设备及软件：PC+Windows 2000+VC 6.0 实验五多态和运算符重载（设计性实验 2学时）目的要求： 掌握运算符重载的方法；学习使用虚函数实现动态多态性。实验内容： 定义Point类，有坐标x,y两个私有成员变量;对Point类重载“+”（相加）、“-”（相减）和“==”（相等）运算符，实现对坐标的改变，要求用友元函数和成员函数两种方法实现。对Point类重载<<运算符，以使得代码 Point p;cout< 定义一个车(vehicle)基类，有虚函数Run、Stop等成员函数，由此派生出自行车（bicycle）类、汽车（motorcar）类，它们都有Run、Stop等成员函数。在主函数中用不同的方法调用Run、Stop成员函数，观察这些函数的执行结果，思考如何实现动态多态性，如果Run、Stop没有被定义为虚函数，执行结果会怎样，把结果和分析写入实验报告。选做，利用类完成求函数的积分（参考教材）。 思考并回答：多态，实现多态性的方法，虚函数，运算符重载，前++，后++，实现运算符重载的方式。 主要仪器设备及软件：PC+Windows 2000+VC 6.0 实验六模板和文件 （设计性实验 2学时）目的要求： 理解模板的作用和语法。 学习掌握C++文件处理类的基本用法。实验内容： 使用函数模板实现一个求3个数最大值的函数，并完成测试。 编写程序，用二进制方式打开指定的一个文件，在每一行前加行号。选做，练习使用STL中的vector模板类。选做，定义一个异常类CException,有成员函数Reason(),用来显示异常的类型。在子函数中触发异常，在主程序中处理异常，观察程序的执行过程。思考并回答：模板，函数模板，类模板，文件，文件读写，文件流类，文件操作方式，文件存储方式； STL，容器，异常处理。 3.主要仪器设备及软件：PC+Windows 2000+VC 6.0 五实验报告的格式（本部分要求各学院设计成表格作为教学大纲附件） 实验完毕，应用专门的实验报告本，根据预习和实验中的现象及数据记录等，及时而认真地写出实验报告。实验报告一般包括以下内容： 实验（序号）实验名称 （一）实验目的 （二）仪器工具及材料列出实验中所使用的主要仪器工具及材料。 （三）内容及程序应简明扼要地写出实验步骤流程。 （四）结果及分析应用文字、表格、图形等形式将数据表示出来。根据实验要求对数据进行分析和误差处理。 （五）问题讨论结合有关理论对实验中的现象、产生的误差等进行讨论和分析，以提高自己的分析问题、解决问题的能力，并提出应注意的事项，也为以后的科学研究打下一定的基础。 六、考核方式、方法及实验成绩评定方法 1、考核方式、方法： 面向对象程序设计实验课成绩占面向对象程序设计总成绩的15%，即共15分。考核方法为采用实验课随堂检查学生完成情况及现场提问让学生回答，根据学生完成情况及答辩情况给分次给出平时成绩，共5分。学生在完成实验后应将自己的实验过程，结果，经验写入实验报告并提交实验报告，实验报告成绩占10分，根据学生实验报告的书写质量及实验出勤情况打出。 2、实验成绩评定方法： 评定各级成绩时，可参考以下标准： （一）优秀（很好）14-15 能正确理解实验的目的要求，能独立、顺利而正确地完成各项实验操作，会分析和处理实验中遇到的问题，能掌握所学的各项实验技能，能较好地完成实验报告及其它各项实验作业，有一定创造精神和能力。有良好的实验工作作风和习惯。 （二）良好（较好）13-14 能理解实验的目的和要求，能认真而正确地完成各项实验操作，能分析和处理实验中遇到的一些问题。能掌握所学实验技能的绝大部分，对难点较大的操作完成有困难。能一般完成实验报告和其它实验作业。有较好的实验习惯和工作作风。 （三）中等（一般）11-12 能粗浅理解实验目的要求，能认真努力进行各项实验操作，但技巧较差。能分析和处理实验中一些较容易的问题，掌握实验技能的大部分。有30%掌握得不好。能一般完成各项实验作业和报告。处理问题缺乏条理。工作作风较好。能认真遵守各项规章制度。学习努力。 （四）及格（较差）8-9 只能机械地了解实验内容，能一般性地按实验步骤完成实验操作，能完成60%所学的实验技能，有些虽作但不准确。遇到问题常常缺乏解决的办法，在别人启发下能作些简单处理，但效果不理想。能一般完成实验报告，能认真遵守实验室各项规章制度，工作中有小的习惯性毛病（如工作无计划，处理问题缺乏条理）。 （五）不及格（很差）0-7 盲目地操作，只掌握50%的所学实验技能。有些实验虽能作，但一般效果不好，操作不正确。工作忙乱无条理。一般能遵守实验室规章制度，但常有小的错误。实验报告较多的时候有结果，遇到问题时说不明原因，在教师指导下也较难完成各项实验作业。或有些小聪明但不努力，不求上进。 七、实验主要应配套仪器设备及台（套）数（以一个实验教学班40人为标准）序号 仪器设备名称 数量 备注 计算机 40台 C++开发工具软件 1套 网络版 八、主要教材及参考书 《C++语言程序设计习题与实验指导》，郑莉、傅仕星编著，北京：清华大学出版社，2004 《面向对象程序设计基础》教学大纲 课程编号： 课程中文名称：面向对象程序设计 课程英文名称：Object-Oriented Programming 总学时： 40 实验学时： 0 上机学时：学分： 2.5 适用专业：软件工程专业 一、课程性质、目的和任务（300字内） 《面向对象程序设计基础》是计算机软件工程专业本科生的一门专业基础课。面向对象软件开发方法是吸收了软件工程领域有益的概念和有效的方法而发展起来的一种软件开发方法。它集抽象性、封装性、继承性和多态性于一体，可以帮助人们开发出模块化的程序，并体现信息隐蔽、可复用、易修改、易扩充等特性。本课程主要介绍面向对象程序设计的方法和C++语言的基本概念及C++语言中的面向对象机制。通过本课程的学习，应使学生能够较好地理解和掌握面向对象程序设计技术的基本概念，掌握面向对象程序的设计方法，并能够在C++环境下（如VC++）开发较大型的应用程序。从而为以后的工作和学习打下基础。 二、课程教学内容及学时分配 第一章、面向对象程序设计概述（3学时） 1.教学内容 1.1面向对象程序设计方法的产生和发展 1.2面向过程和面向对象程序设计方法概述 1.3 面向对象程序设计的基本术语 1.4 面向对象程序设计的基本特征 1.5面向对象程序设计语言 1.6基于Visual Studio 2010的C++应用程序的开发 2.基本要求 了解面向对象技术的发展历程；了解面向过程和面向对象程序设计两种程序设计方法 优缺点；掌握面向对象程序设计的特点；掌握面向对象程序设计的相关术语和基本特征；了解目前常用的面向对象程序设计语言。了解Visual Studio环境下，C++应用程序的开发过程。3.重点、难点 重点：面向对象程序设计的特点（数据的抽象与封装、继承性、多态性）及面向对象的基本术语；C++应用程序的开发环境。 难点：面向对象程序设计的特点（数据的抽象与封装、继承性、多态性）和面向对象的基本术语。 第二章、C++基础（6学时） 1.教学内容 2.1C++程序的组成部分 2.2 命名空间 2.3 C++数据的输入输出 2.4引用 2.5函数 2.6 变量的的作用域与可见性 2.7对象的生存期 2.8 const常量 2.9动态内存分配和释放 2.10编译预处理 2.11文件的输入和输出 2．基本要求 了解C++程序的组成部分；掌握命名空间、变量的的作用域与可见性及生存期的概念；掌握引用及函数的引用参数和返回引用的概念和使用；掌握带有默认参数的函数的使用；掌握内联函数和重载函数的使用；掌握动态内存分配和释放的方法；掌握磁盘文件的输入输出操作方法。3.重点、难点 重点：引用及函数的引用参数和返回引用的概念和使用；动态内存分配和释放的方法；默认参数的函数的使用；内联函数和重载函数的使用。 难点：函数的引用参数和返回引用的使用；掌握磁盘文件的输入输出操作方法。 第三章 类和对象（6学时） 1.教学内容 3.1类和对象的概念 3.2类的定义 3.3对象的创建与使用 3.4构造函数 3.5析构函数 3.6构造函数和析构函数的调用顺序 3.7 对象数组与对象指针 3.8向函数传递对象 3.9对象的赋值和复制 3.10类的组合 2．基本要求 理解类的概念，掌握类的定义方法；理解对象与类的关系，掌握对象的创建和使用方法；掌握构造函数、析构函数的概念和使用方法；掌握拷贝构造函数的使用方法；掌握对象数组和对象指针的特点和使用方法；掌握函数调用中参数的传递方式；理解类的组合的特点。3.重点、难点 重点：构造函数、析构函数的使用方法；对象数组和对象指针的特点和使用方法；函数调用中参数的传递方式。 难点：拷贝构造函数的使用方法；对象数组和对象指针的特点和使用方法；类的组合使用。 第四章、类与对象的其他特性（4学时） 1.教学内容 4.1类的静态成员 4.2友元 4.3类的作用域和对象的生存期 4.4常量类型 2．基本要求 掌握类的静态成员（静态数据成员和静态成员函数）的定义和使用方法；掌握友元函数、友元类的作用、定义和使用方法；了解类的作用域，理解对象的类型和生存期；掌握各种常量的特点、定义和使用方法。3.重点、难点 重点：静态数据成员和静态成员函数的使用方法；友元函数、友元类的使用方法。难点：静态数据成员和静态成员函数的使用方法；类的作用域、对象的作用域及生存周期。 第五章、继承与派生（6学时） 1.教学内容 5.1类的继承与派生概念 5.2基类与派生类 5.3派生类的构造函数和析构函数 5.4多重继承 5.5子类型与赋值兼容规则 5.6程序实例 2．基本要求 理解基类和派生类的概念；掌握派生类的声明、生成过程、继承方式和访问权限；掌握派生类的构造函数和析构函数；掌握多重继承的构造函数和析构函数、构造顺序和析构顺序及多重继承中的二义性；掌握虚基类的概念；理解子类型和赋值兼容规则； 3.重点、难点 重点：派生类的继承方式和访问权限；派生类的构造函数和析构函数的定义；多重继承构造函数和析构函数的构造顺序和析构顺序；多重继承中的二义性；虚基类的定义。 难点：多重继承中的二义性；虚基类的定义；理解子类型和赋值兼容规则。 第六章、多态性（5学时） 1.教学内容 6.1运算符重载 6.2多态性的概念 6.3虚函数 6.4纯虚函数与抽象类 6.5面向对象程序设计 2．基本要求 掌握重载运算符的定义方法；了解运算符重载为成员函数与友元函数的区别；掌握不同类型数据间的转换方法；掌握多态性的概念；掌握虚函数的定义和使用方法；掌握纯虚函数和抽象类的定义；了解面向对象程序设计的基本思想。3.重点、难点 重点：成员函数和友元函数重载运算符；虚函数的使用方法。难点：虚函数的使用方法；纯虚函数和抽象类的定义和使用。 第七章、模板（2学时） 1.教学内容 7.1模板的概念 7.2 函数模板与模板函数 7.3类模板与模板类 2．基本要求 了解模板的概念；掌握函数模板的定义和使用，理解函数模板与模板函数的关系；掌握模板函数显式具体化；掌握类模板的定义和使用，理解类模板与模板类的关系；掌握类模板的派生；掌握类模板的显式具体化。3.重点、难点 重点：函数模板与类模板的使用。难点：类模板的使用。 第八章 文件和流 1.教学内容 8.1 C++的输入/输出 8.2 标准输入流 8.3 标准输出流 8.4 文件的输入和输出 2.基本要求 了解C++的输入/输出的概念；掌握使用cin进行输入；掌握istream类的方法进行输入。掌握使用cout进行输出；掌握格式化输出；掌握ostream类的方法进行输出；掌握文件的输入和输出。3.重点、难点 重点：掌握istream类和ostream类的输入和输出方法；掌握文件的输入和输出。 难点：掌握文件的输入和输出。 面向对象程序设计教程（C++语言描述）题解 第1章 面向对象程序设计概论 一、名词解释 抽象 封装 消息 【问题解答】 面向对象方法中的抽象是指对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。 面向对象方法中的封装就是把抽象出来的对象的属性和行为结合成一个独立的单位，并尽可能隐蔽对象的内部细节。 消息是面向对象程序设计用来描述对象之间通信的机制。一个消息就是一个对象要求另一个对象实施某种操作的一个请求。 二、填空题 （1）目前有面向过程的结构化程序设计方法和面向对象的程序设计方法两种重要的程序设计方法。（2）结构化程序设计方法中的模块由顺序、选择和循环3种基本结构组成。 （3）在结构化程序设计方法中，程序可表示为程序=数据结构+算法； 而面向对象的程序设计方法，程序可表示为程序=对象+消息。 （4）结构化程序设计方法中的基本模块是过程； 而面向对象程序设计方法中的基本模块是类。（5）面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。 三、选择题（至少选一个，可以多选） （1）面向对象程序设计着重于（B）的设计。 A.对象B.类C.算法D.数据 （2）面向对象程序设计中，把对象的属性和行为组织在同一个模块内的机制叫做（C）。 A.抽象 B.继承 C.封装 D.多态（3）在面向对象程序设计中，类通过（D）与外界发生关系。 A.对象 B.类 C.消息 D.接口（4）面向对象程序设计中，对象与对象之间的通信机制是（C）。 A.对象 B.类 C.消息 D.接口（5）关于C++与C语言的关系的描述中，（D）是错误的。 A.C语言是C++的一个子集 B.C语言与C++是兼容的 C.C++对C语言进行了一些改进 D.C++和C语言都是面向对象的 【结果分析】 C语言是面向过程的。C++语言是一种经过改进的更为优化的C语言，是一种混合型语言，既面向过程也面向对象。 （6）面向对象的程序设计将数据结构与（A）放在一起，作为一个相互依存、不可分割的整体来处理。 A.算法 B.信息 C.数据隐藏 D.数据抽象（7）下面（A）不是面向对象系统所包含的要素。 A.重载 B.对象 C.类 D.继承 【结果分析】 面向对象=对象+类+继承+消息+多态（8）下面说法正确的是（BC）。 A.将数据结构和算法臵于同一个函数内，即为数据封装 B.一个类通过继承可以获得另一个类的特性 C.面向对象要求程序员集中于事物的本质特征，用抽象的观点看待程序 D.同一消息为不同的对象接受时，产生的行为是一样的，这称为一致性 【结果分析】 面向对象程序设计方法具有抽象性、封装性、继承性和多态性等特点。将数据结构和算法臵于同一个类内，即为数据封装。同一消息为不同的对象接受时，产生的行为可能是不一样的，这称为多态性。（9）下面说法正确的是（AD）。 A.对象是计算机内存中的一块区域，它可以存放代码和数据 B.对象实际是功能相对独立的一段程序 C.各个对象间的数据可以共享是对象的一大优点 D.在面向对象的程序中，对象之间只能通过消息相互通信 【结果分析】 对象是计算机内存中的一块区域。在对象中，不但存有数据，而且存有代码，使得每个对象在功能上相互之间保持相对独立。对象之间存在各种联系，但它们之间只能通过消息进行通信。 四、判断题 （1）在高级程序设计语言中，一般用类来实现对象，类是具有相同属性和行为的一组对象的集合，它是创建对象的模板。（√）（2）C++语言只支持面向对象技术的抽象性、封装性、继承性等特性，而不支持多态性。（×）【结果分析】 C++语言不仅支持面向对象技术的抽象性、封装性、继承性等特性，而且支持多态性。 （3）面向对象程序设计中的消息应该包含“如何做”的信息。（×）【结果分析】 消息是面向对象程序设计用来描述对象之间通信的机制。向对象“发送消息”只需告诉对象做什么，对象根据这个消息决定如何做。 （4）一个消息只能产生特定的响应效果。（×）【结果分析】 当一个对象发出消息时，由于接收对象的类型可能不同，所以，它们可能做出不同的反应。这样，一个消息可以产生不同的响应效果，这种现象叫做多态。 （5）类的设计和类的继承机制实现了软件模块的可重用性。（√） （6）C++语言和Java语言均不是一个纯正的面向对象的程序设计的语言。（×）【结果分析】 Java语言是一个纯正的面向对象的程序设计语言。（7）学习C++语言是学习面向对象的程序设计方法的唯一途径。（×）【结果分析】 程序设计方法是独立于具体程序设计语言的一种技术，学习C++语言是学习面向对象程序设计方法的重要途径之一。 （8）在C++语言中，类是支持数据封装的工具。（√） 五、简答题 （1）什么是结构化程序设计方法？它有哪些优点和缺点？ 【问题解答】 结构化程序设计方法着眼于系统要实现的功能，从系统的输入输出出发，分析系统要做哪些事情，进而考虑如何做这些事情，自顶向下地对系统的功能进行分解，来建立系统的功能结构和相应的程序模块结构，有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务，便于开发和维护。 随着程序规模与复杂性的增长，这种面向过程的结构化程序设计方法存在明显的不足之处。首先是数据安全性问题。由于数据被每个模块所共用，因此是不安全的，一旦出错，很难查明原因。其次是可 维护性及可重用性差。它把数据结构和算法分离为相互独立的实体，一旦数据结构需要改变时，常常要涉及整个程序，修改工作量极大并容易产生新的错误。每一种相对于老问题的新方法都要带来额外的开销。另外，图形用户界面的应用程序，很难用过程来描述和实现，开发和维护也都很困难。（2）什么是面向对象程序设计方法？它有哪些优点？ 【问题解答】 面向对象的程序设计方法中，将程序设计为一组相互协作的对象而不是一组相互协作的函数。在程序中，属性用数据表示，用来描述对象静态特征； 行为用程序代码实现，用来描述对象动态特征。可见，在面向对象的程序设计方法中，对象是数据结构和算法的封装体。对象之间存在各种联系，它们之间通过消息进行通信。程序可表示为： 程序=对象+消息 在面向对象程序设计中应着重于类的设计。类正是面向对象语言的基本程序模块，通过类的设计来完成实体的建模任务。类通过一个简单的外部接口与外界发生关系。一个类中的操作不会处理到另一个类中的数据，这样程序模块的独立性、数据的安全性就有了良好的保障。程序的执行取决于事件发生的顺序，由顺序产生的消息来驱动程序的执行。不必预先确定消息产生的顺序，更符合客观世界的实际。并且面向对象程序设计方法提供了软件重用、解决大问题和复杂问题的有效途径，具有抽象性、封装性、继承性和多态性等特点。 （3）结构化程序设计方法与面向对象程序设计方法在对待数据结构和算法关系上有 什么不同？ 【问题解答】 结构化程序设计方法中，把数据结构和算法分离为相互独立的实体； 而在面向对象程序设计中，数据结构和算法封装在一起，结合成一个独立的单位，即对象，并尽可能隐蔽对象的内部细节。对象的私有属性只能由这个对象的行为来读取和修改，与外部的联系通过公有行为充当外部接口。 第2章 从C到C++ 一、名词解释 引用内联函数重载函数 【问题解答】 所谓引用就是给对象取一个别名，使用该别名可以存取该对象。换句话说是使新对象和原对象共用一个地址。 内联函数是使用inline关键字声明的函数。重载函数指在同一个作用域内名字相同而参数不同的函数。重载函数通常用来对具有相似行为而数据类型或数据个数不同的操作提供—个通用的名称。 二、填空题 （1）一般情况下，用C++语言编写的程序是由函数加上类组成的。 （2）C++有两种注释符号，一种是//，另一种是 /*……*/。 （3）使用C++风格的输入输出，在程序中必须包含头文件“iostream”。 （4）cin是预定义的标准输入流对象，>>是输入操作符，也称提取运算符。 （5）cout是预定义的标准输出流对象，<<是输出操作符，也称插入运算符。 （6）指针的值是它所指向那个对象的地址值。指针的类型是它所指向对象的类型。指针的内容便是它所指向对象的值。 （7）C++使用运算符 & 来定义一个引用，对引用的存取都是对它所引用的对象的存取。（8）当一个函数调用出现在函数定义之前时，必须先用函数原型对函数进行声明。 （9）C++有值传递和引用传递两种参数传递机制。 （10）使用关键字inline声明的函数称为内联函数。 （11）运算符new用于进行动态内存分配，运算符delete用于释放动态分配的内存。（12）下面程序的输出结果为x=10，y=10； x=100，y=100。#include int *p=&y;*p=100; cout<<“x=”< 三、选择题（至少选一个，可以多选）（1）在整型指针变量p2、p3的定义中，错误的是（A）。 A.int p1，*p2，p3;B.int*p2，p1，*p3;C.int p1，*p2=&p1，*p3;D.int*p2，p1，*p3=&p1;【结果分析】 指针定义的具体格式如下所示： <类型> *<指针名1>，*<指针名2>，…;（2）若有定义“double xx=3.14，*pp=&xx； ”，则*pp等价于（C）。A.&xxB.*xxC.3.14D.xx 【结果分析】 pp指向xx所在的内存单元，这样*pp和xx等价。（3）下面对引用的描述中（C）是错误的。A.引用是某个变量或对象的别名 B.建立引用时，要对它初始化 C.对引用初始化可以使用任意类型的变量 D.引用与其代表的对象具有相同的地址 【结果分析】 所谓引用就是给对象取一个别名，使用该别名可以存取该对象，所以对引用初始化必须使用同类型的变量。 （4）函数没有返回值的时候，应该选择（A）的函数类型。 A.void B.int C.不确定 D.float（5）在函数的定义格式中，下面各组成部分中，（D）是可以省略的。 A.函数名 B.函数体 C.返回值类型 D.函数参数 【结果分析】 函数的定义可以缺省形式参数，此时称为无参函数。 （6）对重载的函数来说，下面叙述不正确的是（D）。 A.参数的类型不同 B.参数的顺序不同 C.参数的个数不同 D.参数的个数、类型、顺序都相同，但函数的返回值类型不同 【结果分析】 对重载的函数来说，编译系统将根据函数参数的类型和个数来判断使用哪一个函数，所以重载函数参数的个数、类型、顺序不能都相同。 （7）下列有关设臵函数参数默认值的描述中，（D）是正确的。 A.对设臵函数参数默认值的顺序没有任何规定 B.函数具有一个参数时不能设臵默认值 C.默认参数要设臵在函数的原型中，而不能设臵在函数的定义语句中 D.设臵默认参数可使用表达式，但表达式中不可用局部变量 【结果分析】 在C++中，在函数原型中可以为一个或多个参数指定默认值。对函数参数设臵默认值要注意以下几点。 ◆若没有声明函数原型，参数的默认值可在函数定义的头部进行设臵，否则必须在函数原型中进行设臵。 ◆在一个指定了默认值的参数右边不能出现没有指定默认值的参数。 ◆设臵默认参数可使用表达式，但表达式中不可用局部变量。 （8）下面说法正确的是（BC）。A.所有的函数都可以说明为内联函数 B.具有循环语句、switch语句的函数不能说明为内联函数 C.使用内联函数，可以加快程序执行的速度，但会增加程序代码的大小 D.使用内联函数，可以减小程序代码大小，但使程序执行的速度减慢 【结果分析】 内联函数主要是解决程序的运行效率问题。在程序编译时，编译系统将程序中出现内联函数调用的地方用函数体进行替换，进而减少了程序运行的时间，但会增加程序代码的大小。它是以空间换取时间，因此内联函数适用于功能不太复杂，但要求被频繁调用的函数。 （9）一个函数功能不太复杂，但要求被频繁调用，应选用（A）。 A.内联函数 B.重载函数 C.递归函数 D.嵌套函数 （10）C++对C语言做了很多改进，下列描述中 使得C语言发生了质变，即从面向过程变成面向对象的是（D）。A.增加了一些新的运算符 B.允许函数重载，并允许设臵默认参数 C.规定函数说明必须用原型 D.引进了类和对象的概念 【结果分析】 面向对象=对象+类+继承+消息+多态 四、判断题 （1）C++程序中，不得使用没有定义或说明的变量。（√） （2）使用const说明常量时，可以不必指出类型。（×）【结果分析】 如果用const 定义的是一个整型常量，则类型说明符int可以省略。 （3）引用被创建时可以用任意变量进行初始化。（×）【结果分析】 对引用初始化必须使用同类型的变量。 （4）一个返回引用的调用函数可以作为左值。（√） （5）函数可以没有参数，也可以没有返回值。（√） （6）没有参数的两个函数是不能重载的。（√）（7）函数可设臵默认参数，但不允许将一个函数的所有参数都设臵为默认参数。（×）【结果分析】 函数可设臵默认参数，且允许将一个函数的所有参数都设臵为默认参数。 （8）运算符new分配的空间由运算符delete释放。（√） 五、简答题 （1）名字空间的用途是什么？ 【问题解答】 名字空间用来防止命名的冲突。（2）引用有何用处？ 【问题解答】 除了独立引用外，在C++程序中，引用的主要用途是用作函数参数和函数的返回值。 （3）比较值调用和引用调用的相同点与不同点。【问题解答】 在值调用机制中，作为实参的表达式的值被复制到由对应的形参名所标识的一个对象中，作为形参的初始值。函数体对形参的访问、修改都是在这个标识对象上操作的，与实参无关，即数据的传递是单向的。 使用引用作函数的形参时，调用函数的实参要用变量名。实参传递给形参，相当于在被调用函数中使用了实参的别名。于是，在被调用函数中对形参的操作实质是对实参的直接操作，即数据的传递是双向的。 （4）内联函数有什么作用？它有哪些特点？ 【问题解答】 内联函数是使用inline关键字声明的函数。在程序编译时，编译系统将程序中出现内联函数调用的地方用函数体进行替换，进而减少了程序运行的时间。 使用内联函数应注意以下几点。◆递归函数不能定义为内联函数。 ◆内联函数一般适合于不含有switch和while等复杂的结构且只有1~5条语句的小函数，否则编译系统将该函数视为普通函数。 ◆内联函数只能先定义后使用，否则编译系统也将该函数视为普通函数。 ◆对内联函数也不能进行异常接口声明。（5）函数原型中的参数名与函数定义中的参数名以及函数调用中的参数名必须一致吗？ 【问题解答】 不必一致。所有的参数是根据位臵和类型而不是名字来区分的。 （6）重载函数时通过什么来区分？ 【问题解答】 编译系统将根据函数参数的类型和个数来判断使用哪一个函数。 六、程序分析题（写出程序的输出结果，并分析结果） #include 【输出结果】 num=60 ref=100 【问题分析】 本题主要考查引用的含义。【结果分析】 程序首先定义一个int类型的对象num，并给它赋初始值50。然后又定义了一个int类型的引用ref，并将它和num相联系。这样，无论是对num还是对ref进行操作，实际上都是对那个一开始放着50的物理单元的内容进行操作。 七、程序设计题 写出一个完整的C++程序，使用系统函数pow（x，y）计算xy的值，注意包含头文件cmath。【问题分析】 本题主要考查简单的输入输出和标准库函数的调用方法。【解题思路】 ① 由于要用到系统函数pow（x，y），所以要包含头文件cmath。 ② 要计算xy的值，首先必须知道x和y的值。为了程序的通用性，最好通过交互的方式输入x和y的值。【参考程序】 // xt2_1.cpp #include cout<<“please input 2 floats to x，y:”;cin>>x>>y; float z=pow（x，y）; cout<<“pow（”< please input 2 floats to x，y:3.1 2 pow（3.1，2）=9.61 第3章 类 与 对 象 一、填空题 （1）类定义中关键字private、public和protected以后的成员的访问权限分别是私有、公有和保护。如果没有使用关键字，则所有成员默认定义为private权限。具有public访问权限的数据成员才能被不属于该类的函数所直接访问。（2）定义成员函数时，运算符“∷”是作用域运算符，“MyClass∷”用于表明其后的成员函数是在“MyClass类”中说明的。 （3）在程序运行时，通过为对象分配内存来创建对象。在创建对象时，使用类作为样板，故称对象为类的实例。 （4）假定Dc是一个类，则执行“Dc a［10］，b（2）”语句时，系统自动调用该类构造函数的次数为11。【结果分析】 创建10个数组元素需调用构造函数10次，创建对象b需调用构造函数1次，所以系统自动调用该类构造函数的总次数为11。 （5）对于任意一个类，析构函数的个数最多为1个。 （6）delete运算符通常用于实现释放该类对象中指针成员所指向的动态存储空间的任务。（7）C++程序的内存格局通常分为4个区： 数据区、代码区、栈区和堆区。 （8）数据定义为全局变量，破坏了数据的 封装性； 较好的解决办法是将所要共享的数据定义为类的 静态成员。 （9）静态数据成员和静态成员函数可由 任意访问权限许可的函数访问。 （10）友元函数和 友元类统称为友元。（11）友元的正确使用能提高程序的效率，但破坏了类的封装性和数据的隐蔽性。 （12）若需要把一个类A定义为一个类B的友元类，则应在类B的定义中加入一条语句： friend class A。 二、选择题（至少选一个，可以多选）（1）以下不属于类访问权限的是（B）。A.public B.staticC.protectedD.private 【结果分析】 类的访问权限有public、protected 和private。（2）有关类的说法不正确的是（BC）。A.类是一种用户自定义的数据类型 B.只有类的成员函数才能访问类的私有数据成员 C.在类中，如不做权限说明，所有的数据成员都是公有的 D.在类中，如不做权限说明，所有的数据成员都是私有的 【结果分析】 类是一种用户自定义的数据类型，类中成员均具有一种访问权限。关键字public、protected 和private以后的成员的访问权限分别是公有、保护和私有的，所有成员默认定义为private的。私有成员是被隐藏的数据，只有该类的成员函数或友元函数才可以访问它。 （3）在类定义的外部，可以被任意函数访问的成员有（C）。 A.所有类成员 B.private或protected的类成员 C.public的类成员 D.public或private的类成员 【结果分析】 类是一种用户自定义的数据类型，类中成员均具有一种访问权限。公有成员定义了类的外部接口。私有成员是被隐藏的数据，只有该类的成员函数或友元函数才可以引用它。保护成员具有公有成员和私有成员的双重性质，可以被该类或派生类的成员函数或友元函数引用。可见在类定义的外部，可以被任意函数访问的成员是public的类成员。（4）关于类和对象的说法（C）是错误的。A.对象是类的一个实例 B.任何一个对象只能属于一个具体的类 C.一个类只能有一个对象 D.类与对象的关系和数据类型与变量的关系相似 【结果分析】 C++语言的类就是一种用户自己定义的数据类型，类和对象的关系就相当于基本数据类型与它的变量的关系，所以任何一个对象只能属于一个具体的类，但一个类可以有多个对象。 （5）设MClass是一个类，dd是它的一个对象，pp是指向dd的指针，cc是dd的引用，则对成员的访问，对象dd可以通过（B）进行，指针pp可以通过（D）进行，引用cc可以通过（B）进行。 A.∷ B..C.& D.-> （6）关于成员函数的说法中不正确的是（C）。A.成员函数可以无返回值 B.成员函数可以重载 C.成员函数一定是内联函数 D.成员函数可以设定参数的默认值 【结果分析】 与普通函数不同的是，成员函数是属于某个类的。成员函数的实现，可以放在类体内，也可以放在类体外。在类体外实现的成员函数不再是内联函数。（7）下面对构造函数的不正确描述是（B）。A.系统可以提供默认的构造函数 B.构造函数可以有参数，所以也可以有返回值 C.构造函数可以重载 D.构造函数可以设臵默认参数 【结果分析】 构造函数不能指定返回类型，即使是void类型也不可以，当然不可能有返回值。 （8）假定A是一个类，那么执行语句“A a，b（3），*p； ”调用了（B）次构造函数。A.1 B.2 C.3 D.4 【结果分析】 声明指针是不会调用构造函数的。 （9）下面对析构函数的正确描述是（AC）。A.系统可以提供默认的析构函数 B.析构函数必须由用户定义 C.析构函数没有参数 D.析构函数可以设臵默认参数 【结果分析】 析构函数的作用是在对象消失时执行一项清理任务。如果一个类中没有定义析构函数，系统将自动生成一个默认析构函数。析构函数没有参数，当然不可能设臵默认参数。 （10）类的析构函数是（D）时被调用的。A.类创建 B.创建对象 C.引用对象 D.释放对象 （11）创建一个类的对象时，系统自动调用（B）； 撤销对象时，系统自动调用（C）。 A.成员函数 B.构造函数 C.析构函数 D.复制构造函数 （12）通常拷贝构造函数的参数是（C）。A.某个对象名 B.某个对象的成员名 C.某个对象的引用名 D.某个对象的指针名 （13）关于this指针的说法正确的是（B）。 A.this指针必须显式说明B.当创建一个对象后，this指针就指向该对象 C.成员函数拥有this指针D.静态成员函数拥有this指针。【结果分析】 this指针是由C++编译器自动产生且较常用的一个隐含对象指针，它不能被显式声明。当创建一个对象时，this指针就初始化指向该对象。但只有非静态成员函数才拥有this指针，并通过该指针来处理对象。 （14）下列关于子对象的描述中，（B）是错误的。 A.子对象是类的一种数据成员，它是另一个类的对象 B.子对象可以是自身类的对象 C.对子对象的初始化要包含在该类的构造函数中 D.一个类中能含有多个子对象作其成员 【结果分析】 子对象不可以是自身类的对象。 （15）对new运算符的下列描述中，（B）是错误的。 A.它可以动态创建对象和对象数组 B.用它创建对象数组时必须指定初始值 C.用它创建对象时要调用构造函数 D.用它创建的对象数组可以使用运算符delete来一次释放 【结果分析】 使用运算符new创建对象数组的格式如下： new <类型说明符> ［<算术表达式>］ 其中，<算术表达式>给出数组的大小，后面不能再跟构造函数参数，所以用它创建对象数组时不能指 定初始值。 （16）对delete运算符的下列描述中，（D）是错误的。 A.用它可以释放用new运算符创建的对象和对象数组 B.用它释放一个对象时，它作用于一个new所返回的指针 C.用它释放一个对象数组时，它作用的指针名前须加下标运算符［ ］ D.用它可一次释放用new运算符创建的多个对象 【结果分析】 用delete一次只能释放用new创建的1个对象，但可释放一个对象数组。 （17）关于静态数据成员，下面叙述不正确的是（C）。 A.使用静态数据成员，实际上是为了消除全局变量 B.可以使用“对象名.静态成员”或者“类名∷静态成员”来访问静态数据成员 C.静态数据成员只能在静态成员函数中引用 D.所有对象的静态数据成员占用同一内存单元 【结果分析】 静态数据成员可以在静态成员函数中引用，也可以在非静态成员函数中引用。 （18）对静态数据成员的不正确描述是（CD）。A.静态成员不属于对象，是类的共享成员 B.静态数据成员要在类外定义和初始化 C.调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针 D.只有静态成员函数可以操作静态数据成员 【结果分析】 this指针是一个局部量，局部于某个对象，而静态成员函数是属于整个类而不是某个对象，它没有this指针。静态成员函数和非静态成员函数均可操作静态数据成员。 （19）下面的选项中，静态成员函数不能直接访问的是（D）。 A.静态数据成员 B.静态成员函数 C.类以外的函数和数据 D.非静态数据成员 【结果分析】 由于静态成员函数没有this指针，它只能直接访问该类的静态数据成员、静态成员函数和类以外的函数和数据，访问类中的非静态数据成员必须通过参数传递方式得到对象名，然后通过对象名来访问。 （20）在类的定义中，引入友元的原因是（A）。A.提高效率 B.深化使用类的封装性 C.提高程序的可读性 D.提高数据的隐蔽性 【结果分析】 友元的作用主要是为了提高效率和方便编程，但友元破坏了类的封装性和隐蔽性，使用时要权衡利 弊。 （21）友元类的声明方法是（A）。 A.friend class<类名>； B.youyuan class<类名>； C.class friend<类名>； D.friends class<类名>； （22）下面对友元的错误描述是（D）。A.关键字friend用于声明友元 B.一个类中的成员函数可以是另一个类的友元 C.友元函数访问对象的成员不受访问特性影响 D.友元函数通过this指针访问对象成员 【结果分析】 友元函数是一个放在类中的普通函数，它没有this指针。 （23）下面选项中，（C）不是类的成员函数。A.构造函数 B.析构函数 C.友元函数 D.拷贝构造函数 三、简答题 （1）类与对象有什么关系？ 【问题解答】 类是一种用户自己定义的数据类型，和其他数据类型不同的是，组成这种类型的不仅可以有数据，而且可以有对数据进行操作的函数。程序员可以使用这个新类型在程序中声明新的变量，具有类类型的变量称为对象。创建对象时，类被用做样板，对象称为类的实例。 （2）类定义的一般形式是什么？其成员有哪几种访问权限？ 【问题解答】 定义类一般形式为： class类名{ public: <公有数据和函数> protected: <保护数据和函数> private: <私有数据和函数> }; 访问权限共有3种： 分别是公有（public）、保护（protected）和私有（private）。 （3）类的实例化是指创建类的对象还是定义类？ 【问题解答】 指创建类的对象。 （4）什么是this指针？它的主要作用是什么？ 【问题解答】 this指针是C++语言为成员函数提供的一个隐含对象指针，它不能被显式声明。this指针是一个局部量，局部于某个对象。不同的对象调用同一个成员函数时，编译器根据this指针来确定应该引用哪一个对象的数据成员。 （5）什么叫做拷贝构造函数？拷贝构造函数何时被调用？ 【问题解答】 拷贝构造函数是一种特殊的构造函数，它的作用是用一个已经存在的对象去初始化另一个对象。为了保证所引用的对象不被修改，通常把引用参数声明为const参数。 在以下3种情况下，拷贝构造函数都会被自动调用： ◆当用类的一个对象去初始化该类的另一个对象时； ◆当函数的形参是类的对象，进行形参和实参结合时； ◆当函数的返回值是类的对象，函数执行完成返回调用者时。 四、程序分析题（写出程序的输出结果，并分析结果）（1） #include using namespace std; class Test { private: int num; public: Test（）;// 默认构造函数 Test（int n）;// 带一个参数构造函数 }; Test∷Test（） { cout<<“Init defa”< Test∷Test（int n） { cout<<“Init”<<“ ”< int main（） { Test x［2］;// 语句1 Test y（15）;// 语句2 return 0;} 【输出结果】 Init defa Init defa Init 15 【问题分析】 本题主要考查构造函数的调用时机和构造函数的匹配问题。【要点提示】 构造函数在创建对象时被自动调用，具体调用哪个构造函数将由编译系统根据重载函数的匹配原则来确定。【结果分析】 ① 程序声明了2个对象x和y，类中有2个构造函数。 ② 程序首先执行语句1，创建对象x，调用默认构造函数。由于对象x是对象数组，每个数组元素被创建时都要调用构造函数，所以默认构造函数被调用了2次，输出第1、2行结果。程序接着执行语句2，创建对象y，调用带一个参数的构造函数，输出第3行结果。（2） #include using namespace std;class Xx { private: int num;public: Xx（int x）{num=x;} // 构造函数 ~Xx（）{cout<<“dst ”< }; int main（） { Xx w（5）;// 语句1 cout<<“Exit main”< return 0;} 【输出结果】 Exit main dst 5 【问题分析】 本题主要考查析构函数的调用时机。【要点提示】 析构函数在释放对象时被自动调用。【结果分析】 ① 程序声明了一个对象w。 ② 程序首先执行语句1，创建对象w，调用构造函数，num得到初值5。程序接着执行语句2，输出第1行结果。当程序结束时，释放对象w，析构函数被调用，输出第2行结果。 （3）将例3.10中的Whole类如下修改，其他部分不变，写出输出结果。 class Whole { public: Whole（int i）;// Whole的有参构造函数 Whole（）{};// Whole的无参构造函数 ~Whole（）;// Whole的析构函数 private: Part p1;// 子对象1 Part p2;// 子对象2 Part p3;// 子对象3 }; Whole∷Whole（int i）:p2（i），p1（）{ cout<<“Constructor of Whole”< Whole∷~Whole（） { cout<<“Destructor of Whole”< 【输出结果】 Default constructor of Part Constructor of Part，3 Default constructor of Part Constructor of Whole Destructor of Whole Destructor of Part，0 Destructor of Part，3 Destructor of Part，0 【问题分析】 本题主要考查子对象初始化的方法和含有子对象时构造函数和析构函数的调用顺序。【要点提示】 ◆当建立X类的对象时，先调用子对象的构造函数，初始化子对象，然后才执行X类的构造函数，初始化X类中的其他成员。 ◆对子对象构造函数的调用顺序取决于这些子对象在类中的说明顺序，与它们在成员初始化列表中给出的顺序无关。 ◆如果X类的构造函数没有给出成员初始化列表，表明子对象将使用默认构造函数进行初始化。◆析构函数的调用顺序与构造函数的调用顺序正好相反。【结果分析】 程序的Whole类中出现了类Part的3个对象p1、p2和p3，作为该类的数据成员，则p1、p2和p3被称为子对象。当建立Whole类的对象w时，子对象p1、p2和p3被建立，相应的构造函数被执行。由于p1在Whole类中先说明，所以先执行它所使用的构造函数，即类Part的默认构造函数，接着p2执行它所使用的有参构造函数，紧接着初始化p3，由于Whole类构造函数的成员初始化列表中没有子对象p3进行初始化的选项，所以执行类Part的默认构造函数，当所有子对象被构造完之后，对象w的构造函数才被执行，从而得到前4行输出结果，而后4行是执行相应析构函数的输出结果。（4） #include using namespace std; class Book { public: Book（int w）; static int sumnum; private: int num;}; Book∷Book（int w） { num=w; sumnum-=w;} int Book∷sumnum=120;// 语句1 int main（） { Book b1（20）;// 语句2 Book b2（70）;// 语句3 cout< return 0;} 【输出结果】 【问题分析】 本题主要考查“在类的范围内所有对象共享静态成员的数据”的含义。【结果分析】 程序中语句1对静态成员sumnum进行初始化，sumnum得到初值120。执行语句2时，调用构造函数，sumnum变为100。接着语句3，再调用构造函数，sumnum变为30。 五、程序设计题 （1）声明一个Circle类，有数据成员radius（半 径）、成员函数area（），计算圆的面积，构造一个Circle的对象进行测试。【问题分析】 本题主要考查类定义的形式、对象成员访问和对象初始化的方法。要求理解类和构造函数的真正含义，特别注意如何将客观事物的属性和行为抽象为类的成员。【解题思路】 ① 题目中已给出了类的基本部分，需要增加一个构造函数来初始化数据成员radius。 ② 为了程序的通用性，圆的半径由键盘输入。【参考程序】 // xt3_1.cpp #include第二篇：《C++面向对象程序设计》教案
第三篇：《面向对象程序设计》(c++)实验教学大纲
第四篇：C++面向对象程序设计教学大纲
第五篇：面向对象程序设计教程(C++语言描述)题解
点击咨询 