思维导图备注

C++编程思想
首页 收藏书籍 阅读记录
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

第2卷 实用编程技术

浏览 1 扫码
  • 小字体
  • 中字体
  • 大字体
2022-01-24 09:36:29
请 登录 再阅读
上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • 出版者的话
  • 出版说明
  • 第1卷 标准C++导引
    • 前言
    • 第1章 对象导言
      • 1.2 对象有一个接口
      • 1.3 实现的隐藏
      • 1.4 实现的重用
      • 1.5 继承：重用接口
      • 1.6 具有多态性的可互换对象
      • 1.7 创建和销毁对象
      • 1.8 异常处理：应对错误
      • 1.9 分析和设计
        • 1.9.2 第1阶段：我们在做什么
        • 1.9.3 第2阶段：我们将如何建立对象
        • 1.9.4 第3阶段：创建核心
        • 1.9.5 第4阶段：迭代用例
        • 1.9.6 第5阶段：进化
        • 1.9.7 计划的回报
      • 1.10 极限编程
        • 1.10.2 结对编程
      • 1.11 为什么C++会成功
        • 1.11.2 延续式的学习过程
        • 1.11.3 效率
        • 1.11.4 系统更容易表达和理解
        • 1.11.5 尽量使用库
        • 1.11.6 利用模板的源代码重用
        • 1.11.7 错误处理
        • 1.11.8 大型程序设计
      • 1.12 为向OOP转变而采取的策略
        • 1.12.2 管理的障碍
      • 1.13 小结
    • 第2章 对象的创建与使用
      • 2.1.2 编译器
      • 2.2 分段编译工具
        • 2.2.2 连接
        • 2.2.3 使用库文件
      • 2.1.3 编译过程
      • 2.3 编写第一个C++程序
        • 2.3.2 名字空间
        • 2.3.3 程序的基本结构
        • 2.3.4 “Hello, World！”
        • 2.3.5 运行编译器
      • 2.4 关于输入输出流
        • 2.4.2 读取输入数据
        • 2.4.3 调用其他程序
      • 2.5 字符串简介
      • 2.6 文件的读写
      • 2.7 vector简介
      • 2.8 小结
      • 2.9 练习
    • 第3章 C++中的C
      • 3.1.2 使用C的函数库
      • 3.2 执行控制语句
        • 3.2.2 if-else语句
        • 3.2.3 while语句
        • 3.2.4 do-while语句
        • 3.2.5 for语句
        • 3.2.6 关键字break和continue
        • 3.2.7 switch语句
        • 3.2.8 使用和滥用goto
        • 3.2.9 递归
      • 3.1.3 通过库管理器创建自己的库
      • 3.3 运算符简介
        • 3.3.2 自增和自减
      • 3.4 数据类型简介
        • 3.4.2 bool类型与true和false
        • 3.4.3 说明符
        • 3.4.4 指针简介
        • 3.4.5 修改外部对象
        • 3.4.6 C++引用简介
        • 3.4.7 用指针和引用作为修饰符
      • 3.5 作用域
      • 3.6 指定存储空间分配
        • 3.6.2 局部变量
        • 3.6.3 静态变量
        • 3.6.4 外部变量
        • 3.6.5 常量
        • 3.6.6 volatile变量
      • 3.7 运算符及其使用
        • 3.7.2 数学运算符
        • 3.7.3 关系运算符
        • 3.7.4 逻辑运算符
        • 3.7.5 位运算符
        • 3.7.6 移位运算符
        • 3.7.7 一元运算符
        • 3.7.8 三元运算符
        • 3.7.9 逗号运算符
        • 3.7.10 使用运算符时的常见问题
        • 3.7.11 转换运算符
        • 3.7.12 C++的显式转换
        • 3.7.13 sizeof—独立运算符
        • 3.7.14 asm关键字
        • 3.7.15 显式运算符
      • 3.8 创建复合类型
        • 3.8.2 用struct把变量结合在一起
        • 3.8.3 用enum提高程序清晰度
        • 3.8.4 用union节省内存
        • 3.8.5 数组
      • 3.9 调试技巧
        • 3.9.2 把变量和表达式转换成字符串
        • 3.9.3 C语言assert（）宏
      • 3.10 函数地址
        • 3.10.2 复杂的声明和定义
        • 3.10.3 使用函数指针
        • 3.10.4 指向函数的指针数组
      • 3.11 make：管理分段编译
        • 3.11.2 本书中的makefile
        • 3.11.3 makefile的一个例子
      • 3.12 小结
      • 3.13 练习
    • 第4章 数据抽象
      • 4.1.2 有害的猜测
      • 4.2 哪儿出问题
      • 4.3 基本对象
      • 4.4 什么是对象
      • 4.5 抽象数据类型
      • 4.6 对象细节
      • 4.7 头文件形式
        • 4.7.2 多次声明问题
        • 4.7.3 预处理器指示#define、#ifdef和#endif
        • 4.7.4 头文件的标准
        • 4.7.5 头文件中的名字空间
        • 4.7.6 在项目中使用头文件
      • 4.8 嵌套结构
      • 4.9 小结
      • 4.10 练习
    • 第5章 隐藏实现
      • 5.2 C++的访问控制
      • 5.3 友元
        • 5.3.2 它是纯面向对象的吗
      • 5.4 对象布局
      • 5.5 类
        • 5.5.2 用访问控制来修改Stack
      • 5.6 句柄类
        • 5.6.2 减少重复编译
      • 5.7 小结
      • 5.8 练习
    • 第6章 初始化与清除
      • 6.2 用析构函数确保清除
      • 6.3 清除定义块
        • 6.3.2 内存分配
      • 6.4 带有构造函数和析构函数的Stash
      • 6.5 带有构造函数和析构函数的Stack
      • 6.6 聚合初始化
      • 6.7 默认构造函数
      • 6.8 小结
      • 6.9 练习
    • 第7章 函数重载与默认参数
      • 7.1.2 类型安全连接
      • 7.2 重载的例子
      • 7.3 联合
      • 7.4 默认参数
      • 7.5 选择重载还是默认参数
      • 7.6 小结
      • 7.7 练习
    • 第8章 常量
      • 8.1.2 const的安全性
      • 8.2 指针
        • 8.2.2 const指针
        • 8.2.3 赋值和类型检查
      • 8.1.3 聚合
      • 8.3 函数参数和返回值
        • 8.3.2 返回const值
        • 8.3.3 传递和返回地址
      • 8.1.4 与C语言的区别
      • 8.4 类
        • 8.4.2 编译期间类里的常量
        • 8.4.3 const对象和成员函数
      • 8.5 volatile
      • 8.6 小结
      • 8.7 练习
    • 第9章 内联函数
      • 9.2 内联函数
        • 9.2.2 访问函数
      • 9.3 带内联函数的Stash和Stack
      • 9.4 内联函数和编译器
        • 9.4.2 向前引用
        • 9.4.3 在构造函数和析构函数里隐藏行为
      • 9.5 减少混乱
      • 9.6 预处理器的更多特征
      • 9.7 改进的错误检查
      • 9.8 小结
      • 9.9 练习
    • 第10章 名字控制
      • 10.1.2 控制连接
      • 10.2 名字空间
        • 10.2.2 使用名字空间
        • 10.2.3 名字空间的使用
      • 10.1.3 其他存储类型说明符
      • 10.3 C++中的静态成员
        • 10.3.2 嵌套类和局部类
        • 10.3.3 静态成员函数
      • 10.4 静态初始化的相依性
      • 10.5 替代连接说明
      • 10.6 小结
      • 10.7 练习
    • 第11章 引用和拷贝构造函数
      • 11.2 C++中的引用
        • 11.2.2 参数传递准则
      • 11.3 拷贝构造函数
        • 11.3.2 拷贝构造函数
        • 11.3.3 默认拷贝构造函数
        • 11.3.4 替代拷贝构造函数的方法
      • 11.4 指向成员的指针
      • 11.5 小结
      • 11.6 练习
    • 第12章 运算符重载
      • 12.2 语法
      • 12.3 可重载的运算符
        • 12.3.2 二元运算符
        • 12.3.3 参数和返回值
        • 12.3.4 不常用的运算符
        • 12.3.5 不能重载的运算符
      • 12.4 非成员运算符
      • 12.5 重载赋值符
      • 12.6 自动类型转换
        • 12.6.2 运算符转换
        • 12.6.3 类型转换例子
        • 12.6.4 自动类型转换的缺陷
      • 12.7 小结
      • 12.8 练习
    • 第13章 动态对象创建
      • 13.1.2 operator new
      • 13.2 重新设计前面的例子
        • 13.2.2 对指针的清除责任
        • 13.2.3 指针的Stash
      • 13.1.3 operator delete
      • 13.3 用于数组的new和delete
      • 13.1.4 一个简单的例子
      • 13.4 耗尽内存
      • 13.1.5 内存管理的开销
      • 13.5 重载new和delete
        • 13.5.2 对于一个类重载new和delete
        • 13.5.3 为数组重载new和delete
        • 13.5.4 构造函数调用
        • 13.5.5 定位new和delete
      • 13.6 小结
      • 13.7 练习
    • 第14章 继承和组合
      • 14.2 继承语法
      • 14.3 构造函数的初始化表达式表
        • 14.3.2 在初始化表达式表中的内建类型
      • 14.4 组合和继承的联合
      • 14.5 名字隐藏
      • 14.6 非自动继承的函数
      • 14.7 组合与继承的选择
        • 14.7.2 私有继承
      • 14.8 protected
      • 14.9 运算符的重载与继承
      • 14.10 多重继承
      • 14.11 渐增式开发
      • 14.12 向上类型转换
        • 14.12.2 向上类型转换和拷贝构造函数
        • 14.12.3 组合与继承（再论）
        • 14.12.4 指针和引用的向上类型转换
        • 14.12.5 危机
      • 14.13 小结
      • 14.14 练习
    • 第15章 多态性和虚函数
      • 15.2 向上类型转换
      • 15.3 问题
      • 15.4 虚函数
      • 15.5 C++如何实现晚捆绑
        • 15.5.2 虚函数功能图示
        • 15.5.3 撩开面纱
        • 15.5.4 安装vpointer
        • 15.5.5 对象是不同的
      • 15.6 为什么需要虚函数
      • 15.7 抽象基类和纯虚函数
      • 15.8 继承和VTABLE
      • 15.9 重载和重新定义
      • 15.10 虚函数和构造函数
        • 15.10.2 虚函数在构造函数中的行为
      • 15.11 析构函数和虚拟析构函数
        • 15.11.2 析构函数中的虚机制
        • 15.11.3 创建基于对象的继承
      • 15.12 运算符重载
      • 15.13 向下类型转换
      • 15.14 小结
      • 15.15 练习
    • 第16章 模板介绍
      • 16.2 模板综述
      • 16.3 模板语法
        • 16.3.2 作为模板的IntStack
        • 16.3.3 模板中的常量
      • 16.4 作为模板的Stash和Stack
      • 16.5 打开和关闭所有权
      • 16.6 以值存放对象
      • 16.7 迭代器简介
        • 16.7.2 带有迭代器的PStash
      • 16.8 为什么使用迭代器
      • 16.9 小结
      • 16.10 练习
  • 第2卷 实用编程技术
    • 前言
    • 第一部分 建立稳定的系统
      • 1.2 抛出异常
      • 第2章 防御性编程
        • 2.2 一个简单的单元测试框架
        • 2.3 调试技术
        • 2.4 小结
        • 2.5 练习
      • 1.3 捕获异常
      • 1.4 异常匹配
      • 1.5 清理
      • 1.6 标准异常
      • 1.7 异常规格说明
      • 1.8 异常安全
      • 1.9 在编程中使用异常
      • 1.10 使用异常造成的开销
      • 1.11 小结
      • 1.12 练习
    • 第二部分 标准C++库
      • 3.2 创建并初始化C++字符串
      • 第4章 输入输出流
        • 4.2 救助输入输出流
        • 4.3 处理流错误
        • 4.4 文件输入输出流
        • 4.5 输入输出流缓冲
        • 4.6 在输入输出流中定位
        • 4.7 字符串输入输出流
        • 4.8 输出流的格式化
        • 4.9 操纵算子
        • 4.10 输入输出流程序举例
        • 4.11 国际化
        • 4.12 小结
        • 4.13 练习
      • 3.3 对字符串进行操作
      • 第5章 深入理解模板
        • 5.2 有关函数模板的几个问题
        • 5.3 模板特化
        • 5.4 名称查找问题
        • 5.5 模板编程中的习语
        • 5.6 模板元编程
        • 5.7 模板编译模型
        • 5.8 小结
        • 5.9 练习
      • 3.4 字符串的查找
      • 第6章 通用算法
        • 6.2 函数对象
        • 6.3 STL算法目录
        • 6.4 创建自己的STL风格算法
        • 6.5 小结
        • 6.6 练习
      • 3.5 字符串的应用
      • 第7章 通用容器
        • 7.2 概述
        • 7.3 更多迭代器
        • 7.4 基本序列容器：vector、Iist和deque
        • 7.5 集合
        • 7.6 堆栈
        • 7.7 队列
        • 7.8 优先队列
        • 7.9 持有二进制位
        • 7.10 关联式容器
        • 7.11 将STL容器联合使用
        • 7.12 清除容器的指针
        • 7.13 创建自己的容器
        • 7.14 对STL的扩充
        • 7.15 非STL容器
        • 7.16 小结
        • 7.17 练习
      • 3.6 小结
      • 3.7 练习
    • 第三部分 专题
      • 8.2 typeid操作符
      • 第9章 多重继承
        • 9.2 接口继承
        • 9.3 实现继承
        • 9.4 重复子对象
        • 9.5 虚基类
        • 9.6 名字查找问题
        • 9.7 避免使用多重继承
        • 9.8 扩充一个接口
        • 9.9 小结
        • 9.10 练习
      • 8.3 多重继承
      • 第10章 设计模式
        • 10.2 模式分类
        • 10.3 简化习语
        • 10.4 单件
        • 10.5 命令：选择操作
        • 10.6 消除对象耦合
        • 10.7 适配器模式
        • 10.8 模板方法模式
        • 10.9 策略模式：运行时选择算法
        • 10.10 职责链模式：尝试采用一系列策略模式
        • 10.11 工厂模式：封装对象的创建
        • 10.12 构建器模式：创建复杂对象
        • 10.13 观察者模式
        • 10.14 多重派遣
        • 10.15 小结
        • 10.16 练习
      • 8.4 合理使用RTTI
      • 第11章 并发
        • 11.2 C++中的并发
        • 11.3 定义任务
        • 11.4 使用线程
        • 11.5 共享有限资源
        • 11.6 终止任务
        • 11.7 线程间协作
        • 11.8 死锁
        • 11.9 小结
        • 11.10 练习
      • 8.5 RTTI的机制和开销
      • 8.6 小结
      • 8.7 练习
暂无相关搜索结果！
    展开/收起文章目录

    二维码

    手机扫一扫，轻松掌上学

    《C++编程思想》电子书下载

    请下载您需要的格式的电子书，随时随地，享受学习的乐趣！
    EPUB 电子书

    书签列表

      阅读记录

      阅读进度: 0.00% ( 0/0 ) 重置阅读进度