微信读书书城C++宝典
首页我的书架登录
书籍封面
C++宝典
李鹏程等编著
微信读书推荐值 78.3%
78.3%
30人点评
推荐
一般
不行
推荐(23)
一般(6)
不行(1)
阅读
2349人
会员卡可读
字数
48.2万字
微信读书推荐值 78.3%
78.3%
30人点评
推荐
一般
不行
推荐(23)
一般(6)
不行(1)
阅读
2349人
会员卡可读
字数
48.2万字
C++宝典李鹏程等编著
微信读书推荐值
78.3%
30人点评
推荐
一般
不行
推荐
一般
不行
推荐(23)
一般(6)
不行(1)
阅读
2349人
电子书
会员卡可读
字数
48.2万字
微信读书推荐值
78.3%
30人点评
推荐
一般
不行
推荐
一般
不行
推荐(23)
一般(6)
不行(1)
阅读
2349人
电子书
会员卡可读
字数
48.2万字
简介

本书分为5部分,分别是C++基础、面向对象编程、标准模板库、底层开发和综合案例。前4部分循序渐进地讲解了C++程序的组成及开发过程、程序中的数据、语句和表达式、程序流程控制、数组与字符串、指针与引用、函数、函数模板、错误与异常处理、宏与预编译、面向对象基础、类的封装、重载操作符和自定义转换、类的继承、多继承和虚拟继承、多态、类模板、文件流、使用标准模板库STL、序列式容器、关联式容器、函数对象和算法、名称空间、位操作和在C++中嵌入汇编等知识。

本书分为5部分,分别是C++基础、面向对象编程、标准模板库、底层开发和综合案例。前4部分循序渐进地讲解了C++程序的组成及开发过程、程序中的数据、语句和表达式、程序流程控制、数组与字符串、指针与引用、函数、函数模板、错误与异常处理、宏与预编译、面向对象基础、类的封装、重载操作符和自定义转换、类的继承、多继承和虚拟继承、多态、类模板、文件流、使用标准模板库STL、序列式容器、关联式容器、函数对象和算法、名称空间、位操作和在C++中嵌入汇编等知识。

简介

本书分为5部分,分别是C++基础、面向对象编程、标准模板库、底层开发和综合案例。前4部分循序渐进地讲解了C++程序的组成及开发过程、程序中的数据、语句和表达式、程序流程控制、数组与字符串、指针与引用、函数、函数模板、错误与异常处理、宏与预编译、面向对象基础、类的封装、重载操作符和自定义转换、类的继承、多继承和虚拟继承、多态、类模板、文件流、使用标准模板库STL、序列式容器、关联式容器、函数对象和算法、名称空间、位操作和在C++中嵌入汇编等知识。

版权

出版社电子工业出版社
出版时间2010年5月
字数482,436
分类计算机-编程设计
试读结束
本书为付费会员卡可读
登录后获得专属福利 · 百万好书免费读
热门想法
复制
划线
写想法
查询
书友想法
评论
0
赞
0
      暂无评论
      发 表
      回复
      赞
      评论详情
        发 表
        写想法
        公开
        确定删除吗?
        取 消
        删 除
        想法 · 0
        写想法
        书友想法
        评论
        0
        赞
        0
            暂无评论
            发 表
            回复
            赞
            评论详情
              发 表
              写想法
              公开
              查询
              继续提问
              Generated by AI
              写想法
              公开
              字号大小
              字体
              目录
              Ai 问书
              笔记
              开启书友想法
              上下滚动阅读
              字号
              浅色
              书籍封面

              C++宝典

              李鹏程等编著
              • 扉页
              • 版权信息
                +书签
              • 前言
              • 本书特色
              • 本书内容及体系结构
              • 本书读者对象
              • 本书作者
              • 第1部分 C++基础
              • 第1章 走进C++
              • 1.1 初识C++
              • 1.1.1 从C到C++
              • 1.1.2 从面向过程到面向对象
              • 1.1.3 认识类与对象
              • 1.1.4 面向对象编程的特点
              • 1.2 C++的应用现状
              • 1.3 C++未来的发展
              • 1.4 如何学习C++
              • 1.5 小结
              • 第2章 C++程序的组成及开发过程
              • 2.1 一般开发过程
              • 2.2 从简单程序开始
              • 2.2.1 书写源代码
              • 2.2.2 编译成目标文件
              • 2.2.3 链接成可执行程序
              • 2.2.4 运行程序
              • 2.3 C++程序的组成
              • 2.4 注释
              • 2.4.1 注释的类型
              • 2.4.2 使用注释的注意事项
              • 2.5 标准IO对象
              • 2.6 使用名称空间
              • 2.7 编译器和编译过程
              • 2.8 选择集成开发环境
              • 2.9 Dev-C++简介
              • 2.9.1 安装
              • 2.9.2 建立工程
              • 2.9.3 编译和运行
              • 2.10 程序的调试
              • 2.10.1 调试的基本过程
              • 2.10.2 调试手段
              • 2.10.3 调试实例
              • 2.11 综合实例
              • 2.12 小结
              • 第3章 程序中的数据
              • 3.1 常量和变量
              • 3.1.1 什么是常量
              • 3.1.2 什么是变量
              • 3.1.3 定义变量
              • 3.1.4 初始化变量
              • 3.1.5 为变量赋值
              • 3.2 数据类型
              • 3.2.1 整型
              • 3.2.2 特殊整型
              • 3.2.3 无符号整型
              • 3.2.4 浮点型
              • 3.2.5 字符型
              • 3.2.6 无符号字符型
              • 3.2.7 转义字符
              • 3.2.8 宽字符型
              • 3.2.9 布尔型
              • 3.3 变量与内存的关系
              • 3.3.1 变量的地址
              • 3.3.2 变量的字节长度
              • 3.3.3 计算数据的字节长度
              • 3.3.4 变量的取值范围
              • 3.4 自定义数据类型
              • 3.4.1结构体
              • 3.4.2 共用体
              • 3.4.3 枚举体
              • 3.5 用宏替换字面常量
              • 3.6 用const定义常量
              • 3.7 综合实例
              • 3.7.1 计算圆的周长和面积
              • 3.7.2 三角形的类型判断和面积计算
              • 3.8 小结
              • 第4章 语句和表达式
              • 4.1 语句和语句块
              • 4.1.1 空格的作用
              • 4.1.2 语句块的组织
              • 4.1.3 语句块中的变量
              • 4.2 什么是表达式
              • 4.3 运算符分类
              • 4.3.1 算术运算符
              • 4.3.2 算术运算的溢出
              • 4.3.3 赋值运算符
              • 4.3.4 自增和自减运算符
              • 4.3.5 关系运算符
              • 4.3.6 逻辑运算符
              • 4.3.7 条件运算符
              • 4.3.8 逗号运算符
              • 4.3.9位运算符
              • 4.3.10 复合赋值运算符
              • 4.4 运算符的优先级和结合性
              • 4.5 类型转换
              • 4.5.1 隐式类型转换
              • 4.5.2 特殊的隐式转换
              • 4.5.3 显式类型转换
              • 4.6 综合实例
              • 4.6.1 找出某个范围内的素数
              • 4.6.2 求最大值
              • 4.7 小结
              • 第5章 程序流程控制
              • 5.1 程序流程的描述
              • 5.1.1伪码
              • 5.1.2 流程图
              • 5.2 分支
              • 5.2.1 if语句
              • 5.2.2 if⋯else语句
              • 5.2.3 if⋯else语句的嵌套
              • 5.2.4 switch语句
              • 5.3 循环
              • 5.3.1 while语句
              • 5.3.2 do⋯while语句
              • 5.3.3 for语句
              • 5.4 循环控制语句
              • 5.4.1 break语句
              • 5.4.2 continue语句
              • 5.5 流程跳转语句goto
              • 5.6 小结
              • 第6章 数组与字符串
              • 6.1 什么是数组
              • 6.2 定义数组
              • 6.3 初始化数组
              • 6.4 操作数组
              • 6.5 数组的缺点
              • 6.6 二维数组
              • 6.6.1 什么是二维数组
              • 6.6.2 定义二维数组
              • 6.6.3 二维数组的初始化
              • 6.6.4 操作二维数组
              • 6.6.5 二维数组的存储
              • 6.7 字符串
              • 6.7.1 什么是字符串
              • 6.7.2 定义字符串
              • 6.7.3 字符串的初始化
              • 6.7.4 操作字符串
              • 6.7.5 字符串的数组
              • 6.8 字符串处理函数
              • 6.8.1 字符串复制函数strcpy
              • 6.8.2 计算字符串长度函数strlen
              • 6.8.3 字符串连接函数strcat
              • 6.8.4 字符串比较函数strcmp
              • 6.9 综合实例
              • 6.9.1 数组元素排序
              • 6.9.2 输出杨辉三角
              • 6.9.3 字符串处理函数的使用
              • 6.10 小结
              • 第7章 指针与引用
              • 7.1 什么是指针
              • 7.1.1 指针与内存的关系
              • 7.1.2 定义指针变量
              • 7.1.3 使用指针指向数据
              • 7.1.4 获取被指数据
              • 7.1.5 指针的运算
              • 7.2 指针与数组
              • 7.2.1 指向数组的指针
              • 7.2.2 使用指针访问数组
              • 7.2.3 指向字符串的指针
              • 7.3 指针与动态内存分配
              • 7.3.1 程序中内存的分配方式
              • 7.3.2 在堆上分配内存
              • 7.3.3 释放堆上的内存
              • 7.4 const与指针
              • 7.4.1 指向const的指针
              • 7.4.2 const指针
              • 7.4.3 指向const的const指针
              • 7.5 引用
              • 7.5.1 定义引用
              • 7.5.2 常引用
              • 7.6 引用与指针的区别
              • 7.7 综合实例
              • 7.7.1 数组元素排序
              • 7.7.2 输出杨辉三角
              • 7.8 小结
              • 第8章 函数
              • 8.1 什么是函数
              • 8.1.1 函数的组成部分
              • 8.1.2 调用函数
              • 8.1.3 为什么要使用函数
              • 8.2 函数的声明和定义
              • 8.2.1 函数的参数列表
              • 8.2.2 调用函数前先声明
              • 8.2.3 在头文件中声明函数
              • 8.2.4 定义函数
              • 8.2.5 函数实例——判断闰年
              • 8.3 参数传递
              • 8.3.1 函数的形参和实参
              • 8.3.2 值传递
              • 8.3.3 参数类型检查
              • 8.3.4 使用默认实参
              • 8.4 指针和引用参数
              • 8.4.1 指针参数
              • 8.4.2 数组参数
              • 8.4.3 引用参数
              • 8.5 函数中的变量
              • 8.5.1 局部变量
              • 8.5.2 全局变量
              • 8.5.3 全局变量的初始化
              • 8.5.4 多个源文件共享全局变量
              • 8.5.5 静态变量
              • 8.5.6 全局静态变量
              • 8.6 递归函数
              • 8.7 内联函数
              • 8.8 函数重载
              • 8.8.1 为什么需要函数重载
              • 8.8.2 什么时侯需要重载函数
              • 8.8.3 函数重载解析
              • 8.9 函数指针
              • 8.9.1 函数地址
              • 8.9.2 定义函数指针
              • 8.9.3 使用函数指针调用函数
              • 8.9.4 函数指针的用途
              • 8.10 综合实例
              • 8.10.1 判断素数
              • 8.10.2 分割字符串
              • 8.11 小结
              • 第9章 函数模板
              • 9.1 为什么要使用函数模板
              • 9.2 定义函数模板
              • 9.2.1 抽取通用算法逻辑
              • 9.2.2 语法
              • 9.2.3 使用非类型参数
              • 9.3 使用函数模板
              • 9.3.1 实例化函数模板
              • 9.3.2 取函数模板的地址
              • 9.3.3 函数模板实参的推演
              • 9.3.4 显式指定函数模板的实参
              • 9.4 实参推演中的类型转换
              • 9.4.1 左值转换
              • 9.4.2 限定符修饰转换
              • 9.4.3 到基类的转换
              • 9.5 函数模板的编译
              • 9.5.1 函数模板的两种编译方式
              • 9.5.2 函数模板实例的编译时机
              • 9.6 函数模板定义中的标识符解析
              • 9.7 函数模板的特化
              • 9.8 函数模板的重载
              • 9.9 函数匹配规则
              • 9.10 综合实例
              • 9.10.1 数组求和函数模板
              • 9.10.2 数组排序函数模板
              • 9.11 小结
              • 第10章 错误与异常处理
              • 10.1 识别和处理错误
              • 10.1.1 利用函数返回值识别错误
              • 10.1.2 对错误结果做出相应处理
              • 10.2 什么是异常
              • 10.2.1 什么时候出现异常
              • 10.2.2 异常与错误的区别
              • 10.3 抛出异常
              • 10.3.1 主动抛出异常
              • 10.3.2 自定义异常类
              • 10.4 捕获异常
              • 10.4.1 try块
              • 10.4.2 异常处理器
              • 10.4.3 异常对象
              • 10.4.4 栈展开
              • 10.4.5 重新抛出
              • 10.4.6 捕获全部异常
              • 10.5 函数与异常
              • 10.5.1 异常规格说明
              • 10.5.2 异常安全的函数
              • 10.6 使用异常的注意事项
              • 10.7 综合实例
              • 10.8 小结
              • 第11章 宏与预编译
              • 11.1 预处理器和编译器
              • 11.2 预处理器的任务
              • 11.2.1 包含文件
              • 11.2.2 搜索头文件
              • 11.2.3 展开宏
              • 11.3 宏的作用
              • 11.3.1 替代字面常量
              • 11.3.2 替代运算符
              • 11.3.3 声明已定义符号
              • 11.3.4 预定义的宏
              • 11.4 带参数的宏
              • 11.4.1 定义带参数的宏
              • 11.4.2 注意宏展开的结果
              • 11.4.3 带参数的宏与函数的异同
              • 11.4.4 特殊的宏符号
              • 11.5 宏指令和预定义的宏
              • 11.5.1 宏指令
              • 11.5.2 利用预定义的宏指令进行有条件编译
              • 11.5.3 文件包含命令和包含警卫
              • 11.6 综合实例
              • 11.7 小结
              • 第2部分 面向对象编程
              • 第12章 面向对象基础
              • 12.1 对象与类详解
              • 12.1.1 什么是对象
              • 12.1.2 什么是类
              • 12.2 对象的特征
              • 12.2.1 封装性
              • 12.2.2 继承性
              • 12.2.3 多态性
              • 12.3 面向过程与面向对象详解
              • 12.3.1 面向过程
              • 12.3.2 面向对象
              • 12.4 面向对象的分析(OOA)
              • 12.4.1 对问题领域进行建模
              • 12.4.2 OOA的基本原则
              • 12.4.3 OOA的基本步骤
              • 12.5 面向对象的设计(OOD)
              • 12.5.1 OOD要解决的问题
              • 12.5.2 OOD的一些基本原则
              • 12.5.3 OOD的基本步骤
              • 12.6 综合实例
              • 12.7 小结
              • 第13章 类的封装
              • 13.1 定义类
              • 13.1.1 声明一个类
              • 13.1.2 类的数据成员
              • 13.1.3 类的成员函数
              • 13.1.4 类的组织结构
              • 13.1.5 分离成员函数的定义与实现
              • 13.2 类对象
              • 13.2.1 定义类对象
              • 13.2.2 访问类对象成员
              • 13.2.3 隐含的this指针
              • 13.3 类成员的访问限制
              • 13.3.1 一般访问限制
              • 13.3.2 私有与安全性
              • 13.3.3 友元
              • 13.4 类的构造函数
              • 13.4.1 构造函数的定义
              • 13.4.2 构造函数的重载
              • 13.4.3 默认构造函数
              • 13.4.4 复制构造函数
              • 13.4.5 构造函数初始化列表
              • 13.5 类的析构函数
              • 13.5.1 析构函数的定义
              • 13.5.2 默认析构函数
              • 13.6 类的static成员
              • 13.6.1 定义static成员
              • 13.6.2 使用static成员
              • 13.7 综合实例
              • 13.7.1 人的活动
              • 13.7.2 自定义字符串类
              • 13.8 小结
              • 第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 输入操作符>>的重载
              • 14.3 赋值操作符
              • 14.3.1 类的赋值操作
              • 14.3.2 浅复制与深复制
              • 14.3.3 重载赋值操作符
              • 14.4 算术和关系操作符的重载
              • 14.4.1 算术操作符的重载
              • 14.4.2 相等操作符的重载
              • 14.4.3 关系操作符的重载
              • 14.5 其他操作符的重载
              • 14.5.1 下标操作符的重载
              • 14.5.2 成员访问操作符的重载
              • 14.5.3 括号操作符的重载
              • 14.6 自定义转换
              • 14.6.1 构造函数转换
              • 14.6.2 操作符转换
              • 14.7 综合实例
              • 14.8 小结
              • 第15章 类的继承
              • 15.1 确定类的层次
              • 15.2 继承的类型
              • 15.2.1 公有继承
              • 15.2.2 私有继承
              • 15.2.3 保护继承
              • 15.3 选择继承方式
              • 15.4 派生类对象的内存布局
              • 15.5 将派生类对象转换为基类对象
              • 15.6 派生类的构造和析构
              • 15.6.1 构造派生类
              • 15.6.2 析构派生类
              • 15.7 使用基类成员
              • 15.8 基类类型的指针和引用
              • 15.9 综合实例
              • 15.10 小结
              • 第16章 多继承和虚拟继承
              • 16.1 为什么要用多继承
              • 16.2 定义多继承
              • 16.3 多继承派生类对象的内存布局
              • 16.4 访问基类成员
              • 16.5 多继承存在的问题
              • 16.6 虚拟继承
              • 16.6.1 虚拟继承的语法
              • 16.6.2 虚拟继承对象的内存布局
              • 16.6.3 虚拟继承中的构造
              • 16.7 虚拟继承的缺点
              • 16.8 综合实例
              • 16.8.1 改进水陆两栖坦克类
              • 16.8.2 改进鸭嘴兽类
              • 16.9 小结
              • 第17章 多态
              • 17.1 什么是多态
              • 17.2 函数、模板和宏的多态性
              • 17.3 动态多态
              • 17.3.1 为什么要用动态多态
              • 17.3.2 如何实现动态多态
              • 17.3.3 用动态多态改进图形绘制程序
              • 17.3.4 动态多态实例——计算不同职员的薪水
              • 17.4 虚函数与模板方法
              • 17.5 纯虚函数与抽象类
              • 17.5.1 纯虚函数
              • 17.5.2 什么时候用纯虚函数
              • 17.5.3 从抽象类派生具体类
              • 17.5.4 仅有纯虚函数的类——接口
              • 17.5.5 图形类的接口
              • 17.6 虚函数与动态绑定
              • 17.6.1 如何实现动态绑定
              • 17.6.2 虚函数的静态调用
              • 17.6.3 虚函数的代价
              • 17.7 虚拟析构函数
              • 17.8 虚函数的默认实参
              • 17.9 综合实例
              • 17.10 小结
              • 第18章 类模板
              • 18.1 什么是类模板
              • 18.2 定义类模板
              • 18.2.1 语法
              • 18.2.2 非类型参数
              • 18.2.3 模板参数的默认实参
              • 18.3 生成类模板的实例
              • 18.3.1 类型参数的模板实例化
              • 18.3.2 非类型参数的模板实例化
              • 18.3.3 类模板范例
              • 18.4 类模板的静态成员
              • 18.5 类模板的友元
              • 18.6 类模板的特化
              • 18.6.1 类模板的全特化
              • 18.6.2 类模板的偏特化
              • 18.6.3 类模板的匹配规则
              • 18.7 综合实例
              • 18.8 小结
              • 第19章 文件流
              • 19.1 文件处理的整个过程
              • 19.2 处理文件流的类
              • 19.3 打开文件
              • 19.3.1 打开文件的函数
              • 19.3.2 打开文件的方式
              • 19.4 操作文件
              • 19.4.1 格式化读写
              • 19.4.2 无格式读数据
              • 19.4.3 无格式写数据
              • 19.5 判断文件流状态
              • 19.5.1 检查文件是否打开
              • 19.5.2 文件流的状态
              • 19.6 重定位读写位置
              • 19.7 关闭文件
              • 19.8 综合实例
              • 19.8.1 模拟生成电子邮件
              • 19.8.2 模拟读电子邮件
              • 19.9 小结
              • 第3部分 标准模板库
              • 第20章 使用标准模板库STL
              • 20.1 STL的形成
              • 20.1.1 STL的历史
              • 20.1.2 STL的各种版本
              • 20.2 STL的组成部分
              • 20.3 容器的分类
              • 20.4 容器的常用方法
              • 20.4.1 初始化容器
              • 20.4.2 增加元素
              • 20.4.3 删除元素
              • 20.4.4 查找元素
              • 20.4.5 修改元素
              • 20.4.6 统计容器数据
              • 20.4.7 其他方法
              • 20.5 配置器
              • 20.6 迭代器
              • 20.6.1 迭代器思想
              • 20.6.2 迭代器分类
              • 20.6.3 定义迭代器变量
              • 20.6.4 迭代器的基本用法
              • 20.6.5 使用迭代器区间
              • 20.6.6 迭代器的有效性
              • 20.7 适配器
              • 20.8 小结
              • 第21章 序列式容器
              • 21.1 向量vector
              • 21.1.1 vector概述
              • 21.1.2 构造vector
              • 21.1.3 处理vector的元素
              • 21.1.4 交换两个容器的元素
              • 21.1.5 使用向量的实例
              • 21.2 双向链表list
              • 21.2.1 list概述
              • 21.2.2 构造list
              • 21.2.3 处理list的节点
              • 21.2.4 链表的拼接和融合
              • 21.2.5 list的反向迭代器
              • 21.3 双端队列deque
              • 21.3.1 deque概述
              • 21.3.2 使用deque
              • 21.4 容器适配器
              • 21.5 栈stack
              • 21.5.1 stack概述
              • 21.5.2 使用stack
              • 21.6 小结
              • 第22章 关联式容器
              • 22.1 关联式容器的存储结构
              • 22.1.1 二叉树的概念
              • 22.1.2 二叉树的表示
              • 22.1.3 二叉树的遍历方法
              • 22.1.4 二叉搜索树
              • 22.1.5 平衡二叉树
              • 22.1.6 关联式容器的元素
              • 22.2 映射map
              • 22.2.1 定义并构造map
              • 22.2.2 map容器的pair结构
              • 22.2.3 使用insert插入数据
              • 22.2.4 使用下标运算符[]插入数据
              • 22.2.5 查找数据
              • 22.2.6 遍历map
              • 22.2.7 删除数据
              • 22.2.8 其他操作
              • 22.2.9 使用map容器管理学生名册
              • 22.3 集合set
              • 22.3.1 定义并构造set
              • 22.3.2 set容器的迭代器
              • 22.3.3 set容器的基本操作
              • 22.3.4 使用set容器管理学生名册
              • 22.4 其他关联式容器
              • 22.5 综合实例
              • 22.6 小结
              • 第23章 函数对象和算法
              • 23.1 函数对象概述
              • 23.1.1 函数对象的定义
              • 23.1.2 用函数对象替代函数指针
              • 23.2 STL函数对象分类
              • 23.2.1 一元函数对象
              • 23.2.2 二元函数对象
              • 23.2.3 算术类函数对象
              • 23.2.4 关系类函数对象
              • 23.2.5 逻辑类函数对象
              • 23.2.6 STL函数对象的一般应用
              • 23.3 函数对象适配器
              • 23.3.1 可以适配的函数对象
              • 23.3.2 绑定器
              • 23.3.3 绑定函数
              • 23.3.4 取反器
              • 23.3.5 取反函数
              • 23.3.6 适配器的级联
              • 23.4 算法概述
              • 23.4.1 算法的特征
              • 23.4.2 算法的复杂度
              • 23.4.3 算法泛化
              • 23.5 STL算法详解
              • 23.5.1 迭代器参数
              • 23.5.2 函数对象参数
              • 23.5.3 算法分类
              • 23.6 遍历算法
              • 23.7 查找算法
              • 23.7.1 查找单个元素
              • 23.7.2 搜索子区间
              • 23.7.3 搜索子区间中的一个值
              • 23.7.4 有序区间的查找算法
              • 23.8 排序算法
              • 23.8.1 sort和stable_sort
              • 23.8.2 partial_sort和partial_sort_copy
              • 23.9 整理算法
              • 23.9.1 分类
              • 23.9.2 随机排列
              • 23.9.3 颠倒
              • 23.9.4 旋转
              • 23.10 小结
              • 第24章 名称空间
              • 24.1 为什么要使用名称空间
              • 24.2 创建名称空间
              • 24.2.1 创建普通名称空间
              • 24.2.2 创建嵌套名称空间
              • 24.2.3 定义名称空间的成员
              • 24.3 使用名称空间
              • 24.3.1 使用整个名称空间
              • 24.3.2 使用名称空间中的名字
              • 24.4 为名称空间创建别名
              • 24.5 匿名名称空间
              • 24.5.1 定义匿名名称空间
              • 24.5.2 匿名名称空间与static的区别
              • 24.6 标准名称空间std
              • 24.7 小结
              • 第4部分 底层开发
              • 第25章 位操作
              • 25.1 数据的表示和编码
              • 25.1.1 数据进制
              • 25.1.2 数据存储
              • 25.2位运算
              • 25.2.1位运算简介
              • 25.2.2 按位与“&”
              • 25.2.3 按位或“|”
              • 25.2.4 按位异或“^”
              • 25.2.5 按位取反“~”
              • 25.2.6 按位左移“<<”
              • 25.2.7 按位右移“>>”
              • 25.2.8位赋值运算符
              • 25.3位运算的应用
              • 25.3.1 设置位
              • 25.3.2 取指定位
              • 25.3.3 特定位取反
              • 25.4位段的定义及应用
              • 25.4.1位段的定义
              • 25.4.2位段的应用
              • 25.5 小结
              • 第26章 C++中嵌入汇编语言
              • 26.1 汇编语言的基本概念
              • 26.1.1 什么是汇编语言
              • 26.1.2 汇编语言的特点
              • 26.1.3 汇编语言的应用领域
              • 26.2 汇编语言的基本语法
              • 26.2.1 通用数据传送指令
              • 26.2.2 累加器专用传送指令
              • 26.2.3 地址传送指令
              • 26.2.4 标志寄存器传送指令
              • 26.2.5 算术指令
              • 26.2.6 逻辑指令
              • 26.2.7 控制转移指令
              • 26.2.8 循环控制指令
              • 26.2.9 子程序调用和返回指令
              • 26.3 汇编语言在C++中的应用
              • 26.3.1 内联汇编的优点
              • 26.3.2 __asm语法
              • 26.3.3 在__asm块里使用汇编语言
              • 26.3.4 在__asm块中使用C/C++元素
              • 26.3.5 一个例子
              • 26.4 小结
              • 第5部分 综合案例
              • 第27章 图书管理系统
              • 27.1 需求分析
              • 27.2 系统设计
              • 27.2.1 总体设计
              • 27.2.2 详细设计
              • 27.2.3 数据库设计
              • 27.3 类设计
              • 27.3.1 创建应用程序
              • 27.3.2 设计图书类
              • 27.3.3 设计图书库类
              • 27.3.4 设计读者类
              • 27.3.5 设计读者库类
              • 27.4 图书管理
              • 27.4.1 查找图书
              • 27.4.2 增加图书
              • 27.4.3 维护图书
              • 27.5 读者管理
              • 27.5.1 查找读者
              • 27.5.2 增加读者
              • 27.5.3 维护读者
              • 27.6 借书模块
              • 27.7 还书模块
              • 27.8 系统集成
              • 27.9 小结
              • 第28章 学生管理系统
              • 28.1 需求分析
              • 28.2 总体设计
              • 28.3 数据结构设计
              • 28.3.1 链表概述
              • 28.3.2 构造单链表
              • 28.3.3 设计数据结构
              • 28.4 类设计
              • 28.4.1 创建应用程序
              • 28.4.2 设计Student类
              • 28.5 详细设计
              • 28.5.1 创建链表
              • 28.5.2 插入节点
              • 28.5.3 添加学生信息
              • 28.5.4 显示学生信息
              • 28.5.5 读入学生信息
              • 28.5.6 编辑学生信息
              • 28.5.8 保存学生信息
              • 28.6 系统集成
              • 28.6.1 设计菜单
              • 28.6.2 绑定菜单功能
              • 28.6.3 设计主函数
              • 28.7 小结
              是否关闭自动购买?
              关闭后,阅读到本书未购买章节均需要手动购买确认。
              取消关闭
              C++宝典
              已读到0% · 共0条笔记
              书籍封面
              你可以在这里记录本书的
              想法、划线、书签
              点评此书
              点评此书
              推荐
              一般
              不行
              公开
              书友想法
              评论
              0
              赞
              0
                  暂无评论
                  发 表
                  回复
                  赞
                  评论详情
                    发 表
                    确定删除吗?
                    取 消
                    删 除
                    《C++宝典》

                    仅支持付费会员使用
                    微信扫码开通付费会员
                    qr

                    仅支持付费会员使用
                    微信扫码开通付费会员
                    qr