顶部
收藏

C++编程基础及应用


作者:
主编 陈波 编者 孔艳林 葛亮 陈恒鑫 刘慧君 杨广超
定价:
58.90 元
版面字数:
710千字
开本:
16开
装帧形式:
平装
版次:
1
最新版次
印刷时间:
2025年
ISBN:
978-7-04-061992-8
物料号:
61992-00
出版时间:
2024-09-02
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机基础课程
三级分类:
程序设计技术

本书是作者在总结20年实际工程应用和教学经验的基础上编著而成,是一本为零基础读者准备的C++程序设计课程教材。通过阅读本书,读者可以掌握C++语言的主要语法,了解基础的算法及计算思维,并通过书中大量的实践案例,获得将语法及算法理论应用于工程实践的切身体验。

本书共分为23章,第1章简述计算机的基本组成及工作原理、集成开发环境的搭建和简单使用方法;第2~11章主要讨论结构化程序设计方法;第12章简述了C++程序的编译及构建过程;第13~21章则聚焦于面向对象程序设计内容;第22、23章以递归分形树、全唐诗数据分析两个案例为基础,讲授Qt平台下C++图形界面程序设计方法、树形数据结构、关系数据库访问等技术内容。受限于篇幅,本书第10章、第11章和第23章以网络形式提供。

本书可作为高等学校计算机相关专业的教学用书,也可作为广大使用C++语言的工程实践者的自学和参考用书。

  • 目录
    • 前辅文
      • 第1章 学习准备
        • 1.1 C及C++语言简史
          • 1.2 计算机与程序设计
            • 1.2.1 计算机组成
              • 1.2.2 内存模型
                • 1.2.3 编译执行
                • 1.3 集成开发环境
                  • 1.4 学习建议
                  • 第2章 变量及简单数据类型
                    • 2.1 世界你好
                      • 2.2 变量
                        • 2.3 格式化输出
                          • 2.4 数据类型
                            • 2.4.1 字符类型
                              • 2.4.2 整数类型
                                • 2.4.3 浮点数类型
                                  • 2.4.4 布尔类型
                                  • 2.5 变量命名
                                    • 2.6 字面量
                                      • 2.6.1 整数
                                        • 2.6.2 字符及字符串
                                          • 2.6.3 浮点数
                                          • 微实践——鸡兔同笼
                                          • 第3章 语法基础
                                            • 3.1 编码风格
                                              • 3.2 常见编码疏漏
                                                • 3.3 操作符
                                                  • 3.3.1 赋值操作符
                                                    • 3.3.2 求模操作符
                                                      • 3.3.3 比较与逻辑
                                                        • 3.3.4 递增与递减
                                                          • *3.3.5 逗号操作符
                                                            • 3.3.6 复合操作符
                                                            • 3.4 操作符优先级
                                                              • 3.5 隐式类型转换
                                                                • 3.5.1 赋值/变量初始化
                                                                  • 3.5.2 表达式
                                                                  • 3.6 显式类型转换
                                                                    • 3.7 使用库函数
                                                                      • 3.8 自定义函数
                                                                        • 3.9 地址
                                                                          • 微实践——地球时间
                                                                            • 3.10 获取用户输入
                                                                              • 3.11 常量
                                                                                • *3.12 名字空间
                                                                                  • 3.13 注释
                                                                                    • 微实践——哈利·波特之心灵感应
                                                                                    • 第4章 分支与循环
                                                                                      • 4.1 if else语句
                                                                                        • 4.2 多分支选择
                                                                                          • 4.3 for循环
                                                                                            • 4.3.1 传统for循环
                                                                                              • 4.3.2 基于范围的for循环
                                                                                              • 微实践——质数判定
                                                                                                • 4.4 break语句
                                                                                                  • 4.5 continue语句
                                                                                                    • 微实践——程序的断点调试
                                                                                                      • 4.6 while循环
                                                                                                        • 微实践——九层之台,起于累土
                                                                                                          • 4.7 do while循环
                                                                                                            • 4.8 switch分支
                                                                                                              • *4.9 goto语句
                                                                                                                • 微实践——发现圆周率
                                                                                                                • 第5章 数组及字符串
                                                                                                                  • 5.1 一维数组
                                                                                                                    • 5.2 元素的下标访问
                                                                                                                      • 5.3 数组初始化
                                                                                                                        • 算法——折半查找
                                                                                                                          • *算法——冒泡排序
                                                                                                                            • 5.4 字符数组
                                                                                                                              • 微实践——缓冲区溢出攻击
                                                                                                                                • 5.5 C++字符串
                                                                                                                                  • 5.6 二维数组
                                                                                                                                    • *算法——计算矩阵乘积
                                                                                                                                      • *5.7 多维数组
                                                                                                                                      • 第6章 指针及引用
                                                                                                                                        • 6.1 指针
                                                                                                                                          • 6.2 空指针
                                                                                                                                            • 6.3 指针的简单应用
                                                                                                                                              • 6.4 指针与数组
                                                                                                                                                • 6.5 指针运算
                                                                                                                                                  • *6.6 指向指针的指针
                                                                                                                                                    • *6.7 main()函数的参数
                                                                                                                                                      • *6.8 指针与常量
                                                                                                                                                        • 6.9 引用
                                                                                                                                                          • 6.10 引用与函数
                                                                                                                                                          • 第7章 函数与抽象
                                                                                                                                                            • 7.1 抽象的威力
                                                                                                                                                              • 7.2 函数的定义
                                                                                                                                                                • 算法——一对兔兔与函数的增长
                                                                                                                                                                  • 7.3 函数与一维数组
                                                                                                                                                                    • 7.4 函数与二维数组
                                                                                                                                                                      • 7.5 变量的作用域
                                                                                                                                                                        • 7.6 递归
                                                                                                                                                                          • *算法——分治法及归并排序
                                                                                                                                                                            • 算法——汉诺塔
                                                                                                                                                                              • *7.7 函数指针
                                                                                                                                                                                • 7.8 默认值参数
                                                                                                                                                                                  • 7.9 内联函数
                                                                                                                                                                                    • 7.10 函数名重载
                                                                                                                                                                                      • 7.11 模板函数
                                                                                                                                                                                      • 第8章 内存模型
                                                                                                                                                                                        • 8.1 stack栈
                                                                                                                                                                                          • 微实践——函数调用的汇编代码分析
                                                                                                                                                                                            • 8.2 堆heap
                                                                                                                                                                                              • 8.2.1 单个堆对象
                                                                                                                                                                                                • 8.2.2 堆对象数组
                                                                                                                                                                                                • 8.3 静态对象
                                                                                                                                                                                                • 第9章 位操作
                                                                                                                                                                                                  • 9.1 二进制及十六进制
                                                                                                                                                                                                    • 9.2 按位取反
                                                                                                                                                                                                      • 9.3 按位与
                                                                                                                                                                                                        • 9.4 按位或
                                                                                                                                                                                                          • *9.5 按位异或
                                                                                                                                                                                                            • 9.6 左移位
                                                                                                                                                                                                              • 9.7 右移位
                                                                                                                                                                                                                • 9.8 置位与复位
                                                                                                                                                                                                                  • 微实践——地铁可以关门了吗?
                                                                                                                                                                                                                  • 第10章 枚举与联合
                                                                                                                                                                                                                    • 第11章 结构
                                                                                                                                                                                                                      • 第12章 编译及构建
                                                                                                                                                                                                                        • 12.1 gcc编译示例
                                                                                                                                                                                                                          • 12.2 预处理
                                                                                                                                                                                                                            • 12.3 编译
                                                                                                                                                                                                                              • 12.4 汇编
                                                                                                                                                                                                                                • 12.5 链接
                                                                                                                                                                                                                                  • 12.6 项目依赖
                                                                                                                                                                                                                                  • 第13章 类与抽象
                                                                                                                                                                                                                                    • 13.1 面向对象
                                                                                                                                                                                                                                      • 13.2 枚举类
                                                                                                                                                                                                                                        • 13.3 创建类
                                                                                                                                                                                                                                          • 13.4 创建对象
                                                                                                                                                                                                                                            • 13.5 内存故事
                                                                                                                                                                                                                                              • 13.6 隐藏的this指针
                                                                                                                                                                                                                                                • 13.7 析构函数
                                                                                                                                                                                                                                                  • 13.8 动态对象
                                                                                                                                                                                                                                                    • 13.9 对象数组
                                                                                                                                                                                                                                                    • 第14章 隐藏的实现
                                                                                                                                                                                                                                                      • 14.1 接口与封装
                                                                                                                                                                                                                                                        • 14.2 访问控制
                                                                                                                                                                                                                                                          • 14.3 标准类实现
                                                                                                                                                                                                                                                            • 14.4 友元
                                                                                                                                                                                                                                                              • 14.5 静态数据成员
                                                                                                                                                                                                                                                                • 14.6 静态成员函数
                                                                                                                                                                                                                                                                  • *微实践——设计模式中的单件
                                                                                                                                                                                                                                                                    • 14.7 常量成员函数
                                                                                                                                                                                                                                                                    • 第15章 代码复用
                                                                                                                                                                                                                                                                      • 15.1 万物皆对象
                                                                                                                                                                                                                                                                        • 15.2 组合
                                                                                                                                                                                                                                                                          • 15.3 继承
                                                                                                                                                                                                                                                                            • 15.4 公有私有及保护继承
                                                                                                                                                                                                                                                                              • *15.5 多重继承
                                                                                                                                                                                                                                                                              • 第16章 对象复制
                                                                                                                                                                                                                                                                                • 16.1 赋值与传值
                                                                                                                                                                                                                                                                                  • 16.2 复制构造
                                                                                                                                                                                                                                                                                    • 16.3 默认复制构造函数
                                                                                                                                                                                                                                                                                      • 16.4 深复制
                                                                                                                                                                                                                                                                                        • 16.5 私有复制构造函数
                                                                                                                                                                                                                                                                                          • 微实践——分形蕨类树叶
                                                                                                                                                                                                                                                                                          • 第17章 操作符重载
                                                                                                                                                                                                                                                                                            • 17.1 复数类
                                                                                                                                                                                                                                                                                              • 17.2 +操作符
                                                                                                                                                                                                                                                                                                • 17.3 <<操作符
                                                                                                                                                                                                                                                                                                  • 17.4 =操作符
                                                                                                                                                                                                                                                                                                    • 17.5 构造函数类型转换
                                                                                                                                                                                                                                                                                                      • 17.6 UserString的深复制
                                                                                                                                                                                                                                                                                                        • 17.7 ++操作符
                                                                                                                                                                                                                                                                                                          • 17.8 智能指针
                                                                                                                                                                                                                                                                                                            • *17.9 智能指针的实现
                                                                                                                                                                                                                                                                                                              • 17.10 \操作符
                                                                                                                                                                                                                                                                                                                • 17.11 类型转换操作符函数
                                                                                                                                                                                                                                                                                                                • 第18章 多态
                                                                                                                                                                                                                                                                                                                  • 18.1 早绑定
                                                                                                                                                                                                                                                                                                                    • 18.2 虚函数及晚绑定
                                                                                                                                                                                                                                                                                                                      • *18.3 晚绑定原理
                                                                                                                                                                                                                                                                                                                        • *18.4 运行时类型识别
                                                                                                                                                                                                                                                                                                                          • 18.5 类型转换
                                                                                                                                                                                                                                                                                                                            • 18.5.1 static_cast
                                                                                                                                                                                                                                                                                                                              • 18.5.2 const_cast
                                                                                                                                                                                                                                                                                                                                • 18.5.3 reinterpret_cast
                                                                                                                                                                                                                                                                                                                                  • *18.5.4 dynamic_cast
                                                                                                                                                                                                                                                                                                                                  • *18.6 纯虚函数及抽象类
                                                                                                                                                                                                                                                                                                                                    • *18.7 多态应用举例
                                                                                                                                                                                                                                                                                                                                    • 第19章 容器与模板
                                                                                                                                                                                                                                                                                                                                      • 19.1 向量
                                                                                                                                                                                                                                                                                                                                        • 19.2 向量的生长
                                                                                                                                                                                                                                                                                                                                          • 19.3 模板数组
                                                                                                                                                                                                                                                                                                                                            • 19.4 数组与链表
                                                                                                                                                                                                                                                                                                                                              • 19.5 迭代器
                                                                                                                                                                                                                                                                                                                                                • 19.5.1 获取迭代器
                                                                                                                                                                                                                                                                                                                                                  • 19.5.2 迭代器算术
                                                                                                                                                                                                                                                                                                                                                    • 19.5.3 折半查找示例
                                                                                                                                                                                                                                                                                                                                                      • 19.5.4 容器元素的修改
                                                                                                                                                                                                                                                                                                                                                        • 19.5.5 容器元素的增加
                                                                                                                                                                                                                                                                                                                                                          • 19.5.6 容器元素的删除
                                                                                                                                                                                                                                                                                                                                                            • 19.5.7 迭代器失效
                                                                                                                                                                                                                                                                                                                                                            • 19.6 关联容器
                                                                                                                                                                                                                                                                                                                                                              • 19.6.1 有序关联容器
                                                                                                                                                                                                                                                                                                                                                                • 19.6.2 无序关联容器
                                                                                                                                                                                                                                                                                                                                                                • 19.7 模板类
                                                                                                                                                                                                                                                                                                                                                                  • 19.8 算法
                                                                                                                                                                                                                                                                                                                                                                    • *19.9 移动语义
                                                                                                                                                                                                                                                                                                                                                                    • 第20章 文件
                                                                                                                                                                                                                                                                                                                                                                      • 20.1 文件及文件系统
                                                                                                                                                                                                                                                                                                                                                                        • 20.2 读写文本文件
                                                                                                                                                                                                                                                                                                                                                                          • 20.2.1 普通文本文件
                                                                                                                                                                                                                                                                                                                                                                            • 20.2.2 逗号分隔值文本文件
                                                                                                                                                                                                                                                                                                                                                                            • 微实践——应用boost库存取结构化文本文件
                                                                                                                                                                                                                                                                                                                                                                              • 20.3 简单读写二进制文件
                                                                                                                                                                                                                                                                                                                                                                                • *20.4 随机读写二进制文件
                                                                                                                                                                                                                                                                                                                                                                                • 第21章 异常
                                                                                                                                                                                                                                                                                                                                                                                  • 21.1 早期的异常处理方式
                                                                                                                                                                                                                                                                                                                                                                                    • 21.2 异常抛出、捕获及处理
                                                                                                                                                                                                                                                                                                                                                                                      • 21.3 调用栈回退
                                                                                                                                                                                                                                                                                                                                                                                        • 21.3.1 正常调用栈回退
                                                                                                                                                                                                                                                                                                                                                                                          • 21.3.2 异常抛出后的调用栈回退
                                                                                                                                                                                                                                                                                                                                                                                          • 21.4 try catch的嵌套
                                                                                                                                                                                                                                                                                                                                                                                            • 微实践——细胞计数
                                                                                                                                                                                                                                                                                                                                                                                            • 第22章 实践——一棵树的构建
                                                                                                                                                                                                                                                                                                                                                                                              • 22.1 图形界面应用程序框架
                                                                                                                                                                                                                                                                                                                                                                                                • 22.1.1 GUI示例
                                                                                                                                                                                                                                                                                                                                                                                                  • 22.1.2 分时系统与消息循环
                                                                                                                                                                                                                                                                                                                                                                                                    • 22.1.3 消息循环与信号/槽机制
                                                                                                                                                                                                                                                                                                                                                                                                    • 22.2 树形数据结构
                                                                                                                                                                                                                                                                                                                                                                                                      • 22.2.1 树
                                                                                                                                                                                                                                                                                                                                                                                                        • 22.2.2 树的递归表达
                                                                                                                                                                                                                                                                                                                                                                                                          • 22.2.3 宽度优先遍历
                                                                                                                                                                                                                                                                                                                                                                                                          • 22.3 创建BuildTree程序的框架
                                                                                                                                                                                                                                                                                                                                                                                                            • 22.3.1 UI工作原理
                                                                                                                                                                                                                                                                                                                                                                                                              • 22.3.2 开辟绘图区域
                                                                                                                                                                                                                                                                                                                                                                                                                • 22.3.3 窗口树形结构及布局
                                                                                                                                                                                                                                                                                                                                                                                                                  • 22.3.4 Top-Left坐标系
                                                                                                                                                                                                                                                                                                                                                                                                                    • 22.3.5 观察调试输出
                                                                                                                                                                                                                                                                                                                                                                                                                      • 22.3.6 响应按钮事件
                                                                                                                                                                                                                                                                                                                                                                                                                      • 22.4 树的递归构造
                                                                                                                                                                                                                                                                                                                                                                                                                        • 22.5 创建一棵树
                                                                                                                                                                                                                                                                                                                                                                                                                          • 22.6 树的遍历与绘制
                                                                                                                                                                                                                                                                                                                                                                                                                            • 22.7 修改树的参数
                                                                                                                                                                                                                                                                                                                                                                                                                              • 22.7.1 创建GridSelection对话框
                                                                                                                                                                                                                                                                                                                                                                                                                                • 22.7.2 打开对话框
                                                                                                                                                                                                                                                                                                                                                                                                                                • 22.8 小结
                                                                                                                                                                                                                                                                                                                                                                                                                                • 第23章 数据分析——唐代诗人的朋友圈
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 参考文献

                                                                                                                                                                                                                                                                                                                                                                                                                                  相关图书