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

第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年下半年高等教育自学考试全国统一命题考试面向对象程序设计                  
 参考答案及解析