面向对象程序设计：解析·思路·习题

　　全书按自考指定教材《面向对象程序设计》一书的相应结构安排，依次阐述了类和对象、构造函数与析构函数、继承和派生类、多态性和虚函数、进一步使用成员函数和运算符重载及流类库，以及模板的重点内容与重点概念，另外，作者在最后讲述了面向对象程序设计的基础。本书结构上每章分5个板块，先介绍知识结构，再给出知识解析和解题思路，最后是同步练习和参考答案。还在附录中给出模拟试题和参考答案以及最近两年的自考试题和参考答案与解析。 本书旨在帮助考生充分认识考试内容和题型，做好应试准备，取得理想成绩。为了帮助读者理解教材内容，专门以图文并茂的形式解析难点，也增加一些新内容以加深理解。这样不仅能满足自学考试训练的需要，而且能提高设计应用程序的能力，起到学以致用的目的。 本书不仅可供自考考生作为《面向对象程序设计》的辅导应试教材参考，也能满足大专院校及社会上学习C++语言的需要，更是帮助训练动手能力的好助手。

暂缺《面向对象程序设计：解析·思路·习题》作者简介

第1章  面向对象及C++基础知识,                   
 1. 1  知识结构                  
 1. 2  知识解析                  
 1. 2. 1  语言的鸿沟                  
 1. 2. 2  C++面向对象程序设计的特点                  
 1. 2. 3  熟悉C++的新特点                  
 1. 2. 4  深入理解指针                  
 1. 2. 5  对指针使用const限定符                  
 1. 2. 6  引用                  
 1. 2. 7  数组                  
 1. 3  解题思路                  
 1. 4  同步练习                  
 1. 5  参考答案                  
 第2章  类和对象                  
 2. 1  知识结构                  
 2. 2. 知识解析                  
 2. 2. 1  正确建立类的基础知识                  
 2. 2. 2  使用类的对象                  
 2. 2. 3  成员函数重载及缺省参数                  
 2. 3  解题思路                  
 2. 3. 1  类对象的性质                  
 2. 3. 2  类的性质                  
 2. 4  同步练习                  
 2. 5  参考答案                  
 第3章  构造函数与析构函数                  
 3. 1  知识结构                  
 3. 2  知识解析                  
 3. 2. 1  构造函数和析构函数                  
 3. 2. 2  缺省构造函数和缺省参数                  
 3. 2. 3  复制构造函数                  
 3. 2. 4  重载对象的赋值运算符                  
 3. 2. 5  对象成员的初始化                  
 3. 3  解题思路                  
 3. 4  同步练习                  
 3. 5  参考答案                  
 第4章  继承和派生类                  
 4. 1  知识结构                  
 4. 2  知识解析                  
 4. 2. 1  单一继承派生类的构造函数和析构函数                  
 4. 2. 2  访问权限和赋值兼容规则                  
 4. 2. 3  两义性及名字支配规则                  
 4. 3  解题思路                  
 4. 4  同步练习                  
 4. 5  参考答案                  
 第5章  多态性和虚函数                  
 5. 1  知识结构                  
 5. 2  知识解析                  
 5. 2. 1  多态性                  
 5. 2. 2  进一步探讨虚函数与实函数的区别                  
 5. 3  解题思路                  
 5. 4  同步练习                  
 5. 5  参考答案                  
 第6章  进一步使用成员函数                  
 6. 1  知识结构                  
 6. 2  知识解析                  
 6. 2. 1  静态成员                  
 6. 2. 2  友元函数                  
 6. 2. 3  const对象和volatile对象                  
 6. 2. 4  指向类成员的指针                  
 6. 2. 5  数组和类                  
 6. 3  解题思路                  
 6. 3. 1  正确理解成员的特征                  
 6. 3. 2  正确理解指向类成员的指针                  
 6. 3. 3  数组和类                  
 6. 4  同步练习                  
 6. 5  参考答案                  
 第7章  运算符重载及流类库                  
 7. 1  知识结构                  
 7. 2  知识解析                  
 7. 2. 1  运算符重载                  
 7. 2. 2  格式控制                  
 7. 2. 3  文件操作                  
 7. 3  解题思路                  
 7. 4  同步练习                  
 7. 5  参考答案,                   
 第8章  模板                  
 8. 1  知识结构                  
 8. 2  知识解析                  
 8. 2. 1  函数模板                  
 8. 2. 2  类模板                  
 8. 3  解题思路                  
 8. 4  同步练习                  
 8. 5  参考答案                  
 第9章  面向对象程序设计基础                  
 9. 1  知识结构                  
 9. 2  知识解析                  
 9. 2. 1  面向对象的主要原则                  
 9. 2. 2  OOA基本模型                  
 9. 2. 3  发现对象并建立对象层                  
 9. 2. 4  定义数据成员                  
 9. 2. 5  定义成员函数                  
 9. 2. 6  如何发现基类和派生类结构                  
 9. 2. 7  接口继承与实现继承                  
 9. 2. 8  类的成员                  
 9. 3  同步练习                  
 9. 4  参考答案                  
 附录                  
 附录A  模拟试题                  
 模拟试题(一)                  
 参考答案                  
 模拟试题(二)                  
 参考答案                  
 附录B  历届考题                  
 2001年下半年高等教育自学考试全国统一命题考试面向对象程序设计                  
 参考答案及解析                  
 2002年下半年高等教育自学考试全国统一命题考试面向对象程序设计                  
 参考答案及解析