书籍详情

C++面向对象程序设计:基础、数据结构与编程思想

C++面向对象程序设计:基础、数据结构与编程思想

作者:(美)Walter Savitch著;周靖译;周靖译

出版社:清华大学出版社

出版时间:2003-12-01

ISBN:9787302075943

定价:¥59.00

购买这本书可以去
内容简介
  查看《C++面向对象程序设计》专题“我几乎看过所有已经出版的C++图书,发现只有这本尤其适合大一学生。它很容易理解,既不过分纠缠于细节,也不遗漏任何关键概念。”——AlanEvans,美国蒙哥马利市社区学院计算机科学系主任“许多作者在为大一学生编写教材时,都使用了过于复杂的例子。WalterSavitch知道如何用范例来有效地阐述一个概念。我喜欢这本书!”——AnneMarchant博士,美国乔治梅森大学本书特色:·根据最新的ANSI/IOSC++标准进行了全面修订·完全通过课程试验,具有很高的正确性和可靠性·编排体系灵活,教师或学生可根据具体需要调整授课(或阅读)顺序·适当添加高级主题(以"选读"形式出现),满足部分学生深入学习C++的需要·针对重要概念(或要点),在相应位置提供总结框(以添加灰色底纹的形式),以便学生巩固所学知识。·大量自测题穿插于相应小节,并在各章末尾提供自测题答案·各章末尾提供富有一定挑战性、但又妙趣横生的编程项目本书是最优秀的C++教材之一。自1995年以来,作者结合自己多年的教学经验,根据教学大纲精心设计并编写了书中内容。本书乃第4版,完全根据最新的ANSI/ISOC++标准对第3版进行了全面的修订,并结合广大教师和读者的优秀建议适当调整和增补了部分内容。考虑到大一学生刚涉足编程,作者还以粗体显示了C++的重要元素,并突出显示了重要的编程概念,同时在各章相应的小节提供自测题,在各章末尾提供小结和有趣而富有挑战性的编程项目。全书共17章,9个附录。在讲解了C++基础知识之后,循序渐进引导学生深入函数、I/O流、类、控制流程、命名空间、数组、字符串、指针和动态数组、递归、模板、指针和链表、派生类以及异常。
作者简介
  (美)Walter Savitch著美国加州圣地亚哥大学教授,计算机科学课程的主要设计者之一。作为一名享有盛名且受人尊敬的作者和教育专家,他的授课和写作风格深受教师和学生欢迎。他编写过多本非常畅销的计算机教材,其中包括Problem Solving withC++:The Object of Programming,ThirdEdition和Data Structures and OtherObjects Using C++,Second Edition。
目录
第1章 计算机和C++编程入门                  
 概述                  
 1.1 计算机系统                  
 1.1.1 硬件                  
 1.1.2 软件                  
 1.1.3 高级语言                  
 1.1.4 编译器                  
 自测题                  
 1.1.5 历史回顾                  
 1.2 编程和问题求解                  
 1.2.1 算法                  
 1.2.2 程序设计                  
 1.2.3 面向对象编程                  
 1.2.4 软件生存期                  
 1.3 C++入门                  
 1.3.1 C++语言的起源                  
 1.3.2 一个C++示范程序                  
 1.3.3 陷阱:在\n中使用错误的斜杠                  
 1.3.4 编程提示:输入和输出语法                  
 1.3.5 简单C程序的布局                  
 1.3.6 陷阱:在include文件名前添加一个空格                  
 1.3.7 编译和运行C++程序                  
 1.3.8 编程提示:让程序运行起来                  
 自测题                  
 1.4 测试和调试                  
 1.4.1 程序错误的种类                  
 1.4.2 陷阱:错误地假定程序正确                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第2章 C++基础知识                  
                   
 概述                  
 预备知识                  
 2.1 变量和赋值                  
 2.1.1 变量                  
 2.1.2 名称:标识符                  
 2.1.3 变量声明                  
 2.1.4 赋值语句                  
 2.1.5 陷阱:未初始化的变量                  
 2.1.6 编程提示:使用有意义的名称                  
 自测题                  
 2.2 输入和输出                  
 2.2.1 使用cout进行输出                  
 2.2.2 include预编译指令和命名空间                  
 2.2.3 转义序列                  
 2.2.4 编程提示:用\n或endl终止每一个程序                  
 2.2.5 格式化带小数点的数字                  
 2.2.6 用cin进行输入                  
 2.2.7 设计输入和输出                  
 2.2.8 编程提示:I/O中的行中断                  
 自测题                  
 2.3 数据类型和表达式                  
 2.3.1 int类型和double类型                  
 2.3.2 其他数字类型                  
 2.3.3 char类型                  
 2.3.4 bool类型                  
 2.3.5 类型的兼容性                  
 2.3.6 算术操作符和表达式                  
 2.3.7 陷阱:除法中的整数                  
 自测题                  
 2.3.8 更多赋值语句                  
 2.4 简单控制流程                  
 2.4.1 一个简单的分支机制                  
 2.4.2 陷阱:连续的不等式                  
 2.4.3 陷阱:错用=来取代==                  
 2.4.4 复合语句                  
 自测题                  
 2.4.5 简单的循环机制                  
 2.4.6 递增操作符和递减操作符                  
 2.4.7 编程示例:信用卡余额                  
 2.4.8 陷阱:无限循环                  
 自测题                  
 2.5 程序风格                  
 2.5.1 缩进                  
 2.5.2 注释                  
 2.5.3 为常量命名                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第3章 过程抽象和返回一个值的函数                  
 概述                  
 预备知识                  
 3.1 自顶向下设计                  
 3.2 预定义函数                  
 3.2.1 使用预定义函数                  
 3.2.2 强制类型转换                  
 3.2.3 强制类型转换的古老形式                  
 3.2.4 陷阱:整数除法丢弃了小数部分                  
 自测题                  
 3.3 程序员自定义函数                  
 3.3.1 函数定义                  
 3.3.2 另一种形式的函数声明                  
 3.3.3 陷阱:实参顺序错误                  
 3.3.4 函数定义语法总结                  
 3.3.5 再论函数定义的位置                  
 自测题                  
 3.4 过程抽象                  
 3.4.1 黑盒的比喻                  
 3.4.2 编程提示:选择形参名称                  
 3.4.3 案例分析:购买比萨                  
 3.4.4 编程提示:使用伪代码                  
 自测题                  
 3.5 局部变量                  
 3.5.1 函数如同小程序                  
 3.5.2 编程实例:豌豆试验田                  
 3.5.3 全局常量和全局变量                  
 3.5.4 传值调用形参是局部变量                  
 3.5.5 再论命名空间                  
 自测题                  
 3.5.6 编程实例:阶乘函数                  
 3.6 重载函数名称                  
 3.6.1 重载入门                  
 3.6.2 编程实例:购买比萨(修订版)                  
 3.6.3 自动类型转换                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第4章 所有子任务的函数                  
 概述                  
 预备知识                  
 4.1 void函数                  
 4.1.1 void函数的定义                  
 4.1.2 编程实例:温度换算                  
 4.1.3 void函数中的return语句                  
 自测题                  
 4.2 传引用调用形参                  
 4.2.1 初探传引用调用                  
 4.2.2 传引用调用详解                  
 4.2.3 编程实例:swap_values函数                  
 4.2.4 混合的参数列表                  
 4.2.5 编程提示:应该使用哪种参数                  
 4.2.6 陷阱:疏忽的局部变量                  
 自测题                  
 4.3 使用过程抽象                  
 4.3.1 由函数来调用函数                  
 4.3.2 前条件和后条件                  
 4.3.3 案例分析:超市定价系统                  
 自测题                  
 4.4 测试和调试函数                  
 Stub和驱动程序                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第5章 I/O流——对象和类入门                  
 概述                  
 预备知识                  
 5.1 流和基本文件I/O                  
 5.1.1 文件之于I/O的重要性                  
 5.1.2 文件I/O                  
 5.1.3 类与对象入门                  
 5.1.4 编程提示:检查文件是否成功打开                  
 5.1.5 文件I/O技术                  
 自测题                  
 5.1.6 追加到文件(选读)                  
 5.1.7 文件名作为输入(选读)                  
 5.2 流I/O工具                  
 5.2.1 用流函数格式化输出                  
 5.2.2 操纵元                  
 自测题                  
 5.2.3 流作为函数实参                  
 5.2.4 编程提示:检查文件尾                  
 5.2.5 命名空间的问题                  
 5.2.6 编程实例:整理文件格式                  
 自测题                  
 5.3 字符I/O                  
 5.3.1 get和put成员函数                  
 5.3.2 putback成员函数(选读)                  
 5.3.3 编程实例:检查输入                  
 5.3.4 陷阱:输入中不期而遇的“\n”                  
 自测题                  
 5.3.5 eof成员函数                  
 自测题                  
 5.3.6 编程实例:编辑文本文件                  
 5.3.7 预定义的字符函数                  
 5.3.8 陷阱:toupper和tolower返回int值                  
 自测题                  
 5.4 继承                  
 5.4.1 流类之间的继承关系                  
 5.4.2 编程实例:另一个new_line函数                  
 5.4.3 函数的默认参数(选读)                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第6章 定义类                  
 概述                  
 预备结构                  
 6.1 结构                  
 6.1.1 用于异种数据的结构                  
 6.1.2 陷阱:结构定义中忘记一个分号                  
 6.1.3 结构作为函数参数                  
 6.1.4 编程提示:使用层次化结构                  
 6.1.5 对结构进行初始化                  
 自测题                  
 6.2 类                  
 6.2.1 定义类和成员函数                  
 自测题                  
 6.2.2 公共成员和私有成员                  
 6.2.3 编程提示:将所有成员变量变成私有                  
 6.2.4 编程提示:定义取值函数和赋值函数                  
 自测题                  
 6.2.5 编程提示:将赋值操作符用于对象                  
 6.2.6 编程实例:BankAccount类(版本1)                  
 6.2.7 总结类的一些特征                  
 自测题                  
 6.2.8 用于初始化的构造函数                  
 6.2.9 编程提示:总是包括一个默认构造函数                  
 6.2.10 陷阱:无参数构造函数                  
 自测题                  
 6.3 抽象数据类型                  
 6.3.1 用于生成抽象数据类型的类                  
 6.3.2 编程实例:类的另一种实现                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第7章 更多的控制流程                  
 概述                  
 预备知识                  
 7.1 使用布尔表达式                  
 7.1.1 布尔表达式求值                  
 7.1.2 陷阱:将布尔表达式转换成int值                  
 自测题                  
 7.1.3 能返回布尔值的函数                  
 自测题                  
 7.1.4 枚举类型(选读)                  
 7.2 多路分支                  
 7.2.1 嵌套语句                  
 7.2.2 编程提示:在嵌套语句中使用花括号                  
 7.2.3 多路if-else语句                  
 7.2.4 编程实例:州税                  
 自测题                  
 7.2.5 switch语句                  
 7.2.6 陷阱:忘记在switch语句中添加break                  
 7.2.7 为菜单使用switch语句                  
 7.2.8 编程提示:在分支语句中使用函数调用                  
 7.2.9 块                  
 7.2.10 陷阱:疏忽局部变量                  
 自测题                  
 7.3 C++循环语句详解                  
 7.3.1 while语句回顾                  
 7.3.2 再论递增操作符和递减操作符                  
 自测题                  
 7.3.3 for语句                  
 7.3.4 陷阱:for语句中多余的分号                  
 7.3.5 应该使用哪种循环                  
 自测题                  
 7.3.6 陷阱:未初始化的变量和无限循环                  
 7.3.7 break语句                  
 7.3.8 陷阱:嵌套循环中的break语句                  
 自测题                  
 7.4 设计循环                  
 7.4.1 求和与求乘积的循环                  
 7.4.2 终止循环                  
 7.4.3 嵌套循环                  
 自测题                  
 7.4.4 调试循环                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                   
 第8章 友元函数和重载操作符                  
 概述                  
 预备知识                  
 8.1 友元函数                  
 8.1.1 编程实例:一个相等性函数                  
 自测题                  
 8.1.2 友元函数                  
 8.1.3 编程提示:定义取值函数和友元函数                  
 8.1.4 编程提示:同时使用成员函数和非成员函数                  
 8.1.5 编程实例:Money类(版本1)                  
 8.1.6 实现digit_to_int(选读)                  
 8.1.7 陷阱:数字常量中的前置零                  
 自测题                  
 8.1.8 const参数修饰符                  
 8.1.9 陷阱:不一致地使用const                  
 自测题                  
 8.2 重载操作符                  
 8.2.1 重载操作符                  
 自测题                  
 8.2.2 用于自动类型转换的构造函数                  
 自测题                  
 8.2.3 重载一元操作符                  
 8.2.4 重载>>和中的其他函数                  
 自测题                  
 11.1.4 C字符串输入和输出                  
 自测题                  
 11.1.5 C字符串到数字的转换和可靠输入                  
 11.2 标准string类                  
 11.2.1 标准类string简介                  
 11.2.2 string类的I/O                  
 自测题                  
 11.2.3 编程提示:getline的其他版本                  
 11.2.4 陷阱:混合使用“cin>>变量, ”和getline                  
 11.2.5 用string类进行字符串处理                  
 11.2.6 编程实例:回文测试                  
 自测题                  
 11.2.7 string对象和C字符串之间的转换                  
 11.3 向量                  
 11.3.1 向量基础知识                  
 11.3.2 陷阱:使用方括号时超出向量长度                  
 11.3.3 编程提示:向量赋值具有良好行为                  
 11.3.4 效率问题                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第12章 指针和动态数组                  
 概述                  
 预备知识                  
 12.1 指针                  
 12.1.1 指针变量                  
 自测题                  
 12.1.2 基本内存管理                  
 12.1.3 陷阱:虚悬指针                  
 12.1.4 静态变量和自动变量                  
 12.1.5 编程提示:定义指针类型                  
 自测题                  
 12.2 动态数组                  
 12.2.1 数组变量和指针变量                  
 12.2.2 创建和使用动态数组                  
 自测题                  
 12.2.3 指针运算(选读)                  
 自测题                  
 12.2.4 多维动态数组(选读)                  
 12.3 类和动态数组                  
 12.3.1 编程实例:一个字符串变量类                  
 12.3.2 析构函数                  
 12.3.3 陷阱:指针作为传值调用参数                  
 12.3.4 拷贝构造函数                  
 自测题                  
 12.3.5 重载赋值操作符                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第13章 递归                  
 概述                  
 预备知识                  
 13.1 面向任务的递归函数                  
 13.1.1 案例分析:垂直数字                  
 13.1.2 深入递归                  
 13.1.3 陷阱:无穷递归                  
 自测题                  
 13.1.4 用于递归的堆栈                  
 13.1.5 陷阱:堆栈溢出                  
 13.1.6 递归与迭代                  
 自测题                  
 13.2 面向值的递归函数                  
 13.2.1 返回值的递归函数的泛型                  
 13.2.2 编程实例:另一个Powers函数                  
 自测题                  
 13.3 递归思想                  
 13.3.1 递归设计技术                  
 13.3.2 案例分析:二叉搜索(递归思想示例)                  
 13.3.3 编程实例:一个递归成员函数                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第14章 模板                  
 概述                  
 预备知识                  
 14.1 用于算法抽象的模板                  
 14.1.1 函数模板                  
 14.1.2 陷阱:编译器的复杂性                  
 自测题                  
 14.1.3 编程实例:一个泛化的排序函数                  
 14.1.4 编程提示:如何定义模板                  
 14.1.5 陷阱:为不恰当的类型使用模板                  
 自测题                  
 14.2 用于数据抽象的模板                  
 14.2.1 类模板的语法                  
 14.2.2 编程实例:一个数组类                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第15章 指针和链接                  
 概述                  
 预备知识                  
 15.1 节点和链表                  
 15.1.1 节点                  
 自测题                  
 15.1.2 链表                  
 15.1.3 在表头插入一个节点                  
 15.1.4 陷阱:丢失节点                  
 15.1.5 搜索链表                  
 15.1.6 指针作为迭代器                  
 15.1.7 在列表中插入和移除节点                  
 15.1.8 陷阱:为动态数据结构使用赋值操作符                  
 自测题                  
 15.2 一个链表应用程序                  
 15.2.1 堆栈                  
 15.2.2 编程实例:一个堆栈类                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第16章 继承                  
 概述                  
 预备知识                  
 16.1 继承基础                  
 16.1.1 派生类                  
 16.1.2 派生类中的构造函数                  
 16.1.3 陷阱:使用来自基类的私有成员变量                  
 16.1.4 陷阱:私有成员函数根本不会继承                  
 16.1.5 protected限定符                  
 自测题                  
 16.1.6 重定义成员函数                  
 16.1.7 重定义与重载的比较                  
 16.1.8 访问重定义的基函数                  
 自测题                  
 16.2 继承细节                  
 16.2.1 不继承的函数                  
 16.2.2 派生类中的赋值操作符和拷贝构造函数                  
 16.2.3 派生类中的析构函数                  
 自测题                  
 16.3 多态性                  
 16.3.1 晚期绑定                  
 16.3.2 C++中的虚函数                  
 自测题                  
 16.3.3 虚函数和扩展类型兼容性                  
 16.3.4 陷阱:切片问题                  
 16.3.5 陷阱:不使用虚成员函数                  
 16.3.6 陷阱:试图对虚成员函数定义不齐全的类进行编译                  
 16.3.7 编程提示:虚析构函数                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 第17章 异常处理                  
 概述                  
 预备知识                  
 17.1 异常处理基础                  
 17.1.1 异常处理的一个玩具式例子                  
 自测题                  
 17.1.2 定义自己的异常类                  
 17.1.3 多个throw和catch                  
 17.1.4 陷阱:首先捕捉较具体的异常                  
 17.1.5 编程提示:异常类可能微不足道                  
 17.1.6 在函数中抛出异常                  
 17.1.7 异常规范                  
 17.1.8 陷阱:派生类中的异常规范                  
 自测题                  
 17.2 用于异常处理编程技术                  
 17.2.1 抛出异常的时机                  
 17.2.2 陷阱:未捕捉的异常                  
 17.2.3 陷阱:嵌套的try-catch块                  
 17.2.4 陷阱:滥用异常                  
 17.2.5 异常类层次结构                  
 17.2.6 测试可用内存                  
 17.2.7 重新抛出异常                  
 自测题                  
 小结                  
 自测题答案                  
 编程项目                  
 附录1 C++关键字                  
 附录2 操作符的优先级                  
 附录3 ASCII字符集                  
 附录4 部分库函数                  
 附录5 assert语句                  
 附录6 内联函数                  
 附录7 重载数据索引方括号                  
 附录8 this指针                  
 附录9 将操作符重载为成员操作符                   

猜您喜欢

读书导航