思维导图备注

零基础学C++
首页 收藏书籍 阅读记录
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

写给未来的程序员

浏览 2 扫码
  • 小字体
  • 中字体
  • 大字体
2022-01-24 09:39:14
请 登录 再阅读
上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • 写给未来的程序员
  • 前言
  • 第一篇 C++基础
    • 1.1.2 计算机软件
    • 1.2 程序设计语言
      • 1.2.2 汇编语言
      • 1.2.3 高级语言
      • 1.2.4 数据结构和算法
      • 1.2.5 面向过程的程序设计(POP)
      • 1.2.6 面向对象的程序设计(OOP)
    • 第2章 开始C++之旅
      • 2.1.2 编译预处理与新旧标准
      • 2.2 变量与基本类型
        • 2.2.2 整型
        • 2.2.3 浮点型
        • 2.2.4 基本字符型
        • 2.2.5 宽字符型
        • 2.2.6 布尔型
      • 2.1.3 主函数
      • 2.3 常量
        • 2.3.2 字符型常量
        • 2.3.3 字符串常量
        • 2.3.4 符号常量
        • 2.3.5 枚举(Enum)常量
      • 2.1.4 名称空间
      • 2.4 运算符与表达式
        • 2.4.2 逻辑运算
        • 2.4.3 短路表达式
        • 2.4.4 关系运算
        • 2.4.5 大有文章:变量是否为“0”
        • 2.4.6 条件运算
        • 2.4.7 位运算
        • 2.4.8 赋值运算
        • 2.4.9 ++和——
        • 2.4.10 逗号表达式
        • 2.4.11 sizeof运算符与sizeof表达式
        • 2.4.12 运算符的优先级和结合性
      • 2.1.5 C++语素
      • 2.5 类型转换
        • 2.5.2 表达式中的转换
        • 2.5.3 强制类型转换
        • 2.5.4 函数调用、传递参数时的类型转换
      • 2.6 流程控制语句
        • 2.6.2 switch结构
        • 2.6.3 if……else……结构和switch结构的比较
        • 2.6.4 for循环结构
        • 2.6.5 for循环结构嵌套
        • 2.6.6 while循环结构
        • 2.6.7 do……while循环结构
        • 2.6.8 循环语句的效率
        • 2.6.9 流程转向控制语句之break
        • 2.6.10 流程转向控制语句之continue
        • 2.6.11 自由转向语句goto
        • 2.6.12 程序中止函数exit()
      • 2.7 小结
    • 1.3 C++简介
      • 1.3.2 C++语言特点
      • 1.3.3 C++程序开发基本过程
    • 1.4 C++开发环境的搭建
      • 1.4.2 开发步骤
    • 1.5 第一个C++程序
    • 1.6 小结
  • 第二篇 C++过程开发
    • 3.2 一维数组
      • 3.2.2 初始化一维数组
      • 3.2.3 一维数组应用举例
      • 3.2.4 数组操作注意事项
    • 第4章 指针和引用
      • 4.1.2 初始化指针变量
      • 4.2 指针的运算
        • 4.2.2 同类型指针间的比较
        • 4.2.3 同类型指针相减
      • 4.1.3 指向指针的指针
      • 4.3 动态内存分配
        • 4.3.2 使用delete动态释放动态申请的内存
        • 4.3.3 使用new申请动态数组
        • 4.3.4 不要使用或释放已经释放的内存块
        • 4.3.5 使用malloc和free动态申请内存
        • 4.3.6 动态内存申请并不一定成功
      • 4.1.4 指针赋值
      • 4.4 指针和const
        • 4.4.2 禁止改写间接引用
        • 4.4.3 既禁止改写指针,又禁止改写间接引用
      • 4.5 指针与数组
        • 4.5.2 数组元素的指针形式
        • 4.5.3 指向数组的指针
        • 4.5.4 指针数组
      • 4.6 引用
        • 4.6.2 引用的特点
        • 4.6.3 引用的使用限制
        • 4.6.4 其他要说明的问题
      • 4.7 小结
    • 3.3 C风格字符串
      • 3.3.2 字符数组的cin和cout
      • 3.3.3 get()函数和getline()函数
      • 3.3.4 cin与get()/getline()函数的搭配问题
      • 3.3.5 访问C风格字符串中的某个元素
      • 3.3.6 C风格字符串处理函数
    • 第5章 结构、共用体和链表
      • 5.1.2 结构变量的声明和使用
      • 5.2 共用体
        • 5.2.2 共用体和结构的不同
        • 5.2.3 共用体变量的声明和初始化
        • 5.2.4 共用体使用举例
        • 5.2.5 共用体的sizeof
      • 5.1.3 结构变量的初始化
      • 5.3 结构数组和共用体数组
        • 5.3.2 共用体数组的声明和初始化
      • 5.1.4 结构变量间是否可以相互赋值
      • 5.4 指向结构的指针
        • 5.4.2 结构指针的初始化
        • 5.4.3 使用指针访问结构成员
      • 5.1.5 结构体变量的sizeof
      • 5.5 链表
        • 5.5.2 创建链表
        • 5.5.3 链表与数组的区别
        • 5.5.4 链表的遍历和查找
        • 5.5.5 链表的插入和删除
      • 5.6 小结
    • 3.4 多维数组
      • 3.4.2 初始化多维数组
      • 3.4.3 多维数组应用举例
      • 3.4.4 多维数组在内存中是如何排列元素的
    • 第6章 用函数合理组织程序
      • 6.1.2 抽象和封装
      • 6.2 函数定义
        • 6.2.2 函数体
        • 6.2.3 函数定义补充说明
      • 6.1.3 实现一个函数
      • 6.3 函数声明
        • 6.3.2 如何声明一个函数
        • 6.3.3 分割程序文件
      • 6.4 函数调用
        • 6.4.2 参数类型转换
        • 6.4.3 值传递
        • 6.4.4 指针传递
        • 6.4.5 引用传递
        • 6.4.6 对3种传递的补充
        • 6.4.7 缺省参数调用
        • 6.4.8 inline函数
      • 6.5 递归
      • 6.6 函数的重载
        • 6.6.2 如何实现函数重载
        • 6.6.3 陷阱:隐式转换导致重载函数出现二义性
      • 6.7 C++如何使用内存
        • 6.7.2 静态存储(编译器预分配)
      • 6.8 作用域与可见域
        • 6.8.2 可见域
        • 6.8.3 函数的作用域和可见域
      • 6.9 小结
    • 3.5 小结
    • 第7章 关于函数的高级专题
      • 7.1.2 野指针
      • 7.2 重申:函数参数传递和返回机制
        • 7.2.2 函数返回时的“副本”
      • 7.1.3 试图修改常量
      • 7.3 函数与指针
        • 7.3.2 typedef
        • 7.3.3 通过函数指针将函数作为另一个函数的参数
        • 7.3.4 函数指针数组
        • 7.3.5 返回函数指针的函数
        • 7.3.6 带参主函数
      • 7.1.4 用错sizeof
      • 7.4 函数与数组
        • 7.4.2 通过指针得到多于1个的回传值
      • 7.1.5 内存越界访问
      • 7.5 函数与结构体、共用体及类对象
        • 7.5.2 3种返回机制
      • 7.1.6 变量的初始化
      • 7.6 函数编写的建议
        • 7.6.2 检查输入参数的有效性
        • 7.6.3 函数返回类型的判断
      • 7.7 小结
  • 第三篇 面向对象的C++
    • 8.1.2 类是分层的
    • 8.2 C++类的定义
      • 8.2.2 类定义示例
      • 8.2.3 class和struct
    • 第9章 关于对象的高级专题
      • 9.2 类定义的作用域与可见域
      • 9.3 对象的生存期、作用域和可见域
        • 9.3.2 对象内存释放与堆内存
      • 9.4 友元
        • 9.4.2 友元之成员函数
        • 9.4.3 友元函数的重载
        • 9.4.4 友元类
        • 9.4.5 友元是否破坏了封装性
      • 9.5 运算符重载
        • 9.5.2 以成员函数形式重载运算符
        • 9.5.3 以友元函数形式重载运算符
        • 9.5.4 友员函数形式和成员函数形式的比较
        • 9.5.5 对运算符重载的补充说明
      • 9.6 运算符重载范例
        • 9.6.2 函数调用运算符
        • 9.6.3 下标运算符
      • 9.7 类型转换
        • 9.7.2 由自定义类型转换为其他类型
        • 9.7.3 隐式转换带来的二义性
      • 9.8 重载函数选择规则
        • 9.8.2 什么是完全匹配
      • 9.9 小结
    • 8.1.3 类和对象的关系
    • 8.3 C++类的实现
      • 8.3.2 在类定义的外部定义成员函数
    • 第10章 继 承
      • 10.1.2 继承的层次性
      • 10.2 派生类
        • 10.2.2 protected成员与protected派生
      • 10.3 多基派生
        • 10.3.2 二义性问题
        • 10.3.3 解决方案
      • 10.4 虚基类
        • 10.4.2 解决方案
        • 10.4.3 虚基派生二义性与多基派生二义性不同
      • 10.5 派生类的构造函数和析构函数
        • 10.5.2 派生类的析构函数
        • 10.5.3 多基派生类的构造函数和析构函数
        • 10.5.4 虚基派生的构造函数和析构函数
      • 10.6 分清继承还是组合
        • 10.6.2 组合
      • 10.7 基类与派生类对象间的相互转换
        • 10.7.2 多基继承时的情况
        • 10.7.3 公共基类
        • 10.7.4 虚基类的情况
      • 10.8 小结
    • 8.4 C++类的使用
      • 8.4.2 对象的作用域、可见域和生存期
    • 第11章 多 态
      • 11.1.2 动态联编
      • 11.2 虚函数的访问
        • 11.2.2 指针访问
        • 11.2.3 引用访问
        • 11.2.4 类内访问
        • 11.2.5 在构造函数或析构函数中访问
      • 11.1.3 为什么需要虚函数
      • 11.3 纯虚函数与抽象类
        • 11.3.2 抽象类
        • 11.3.3 另一种抽象类:类中只定义了protected型的构造函数
        • 11.3.4 延伸:构造函数能否为private型
        • 11.3.5 虚析构函数
      • 11.1.4 虚函数的声明和定义
      • 11.4 虚函数引入的二义性
        • 11.4.2 共同基类和虚继承
      • 11.5 重载、覆盖与隐藏
        • 11.5.2 覆盖
        • 11.5.3 隐藏
      • 11.6 小结
    • 8.5 对象的创建和撤销
      • 8.5.2 构造函数可以有参数
      • 8.5.3 构造函数支持重载
      • 8.5.4 构造函数允许按参数缺省方式调用
      • 8.5.5 初始化表达式
      • 8.5.6 析构函数
      • 8.5.7 显式调用析构函数
    • 8.6 复制构造函数
      • 8.6.2 缺省复制构造函数带来的问题
      • 8.6.3 解决方案—显式定义复制构造函数
      • 8.6.4 关于构造函数和复制构造函数
    • 8.7 特殊数据成员
      • 8.7.2 引用成员
      • 8.7.3 类对象成员
      • 8.7.4 特别说明
      • 8.7.5 static数据成员
    • 8.8 特殊函数成员
      • 8.8.2 const与成员函数
    • 8.9 对象的组织
      • 8.9.2 指向对象的指针
      • 8.9.3 对象的大小
      • 8.9.4 this指针
      • 8.9.5 对象数组
      • 8.9.6 对象链表
    • 8.10 为对象动态分配内存
      • 8.10.2 使用new和delete为对象数组分配/释放动态空间
      • 8.10.3 malloc和free能否为对象动态申请内存
    • 8.11 小结
  • 第四篇 泛型编程
    • 12.1.2 模板的定义
    • 12.2 函数模板
      • 12.2.2 隐式实例化
      • 12.2.3 显式实例化
      • 12.2.4 特化
      • 12.2.5 重载
      • 12.2.6 优先级与执行顺序
    • 第13章 标准模板库(STL)
      • 13.1.2 适配器
      • 13.2 使用序列式容器
        • 13.2.2 所有容器都支持的特征
        • 13.2.3 序列式容器中元素的插入和删除
        • 13.2.4 vector容器
        • 13.2.5 deque容器
        • 13.2.6 list容器
      • 13.1.3 迭代器
      • 13.3 使用关联式容器
        • 13.3.2 multiset容器
        • 13.3.3 map容器
        • 13.3.4 multimap容器
      • 13.1.4 算法
      • 13.4 关联式容器支持的成员函数操作
        • 13.4.2 元素的删除
        • 13.4.3 元素的查找与访问
      • 13.5 迭代器
        • 13.5.2 迭代器类型
        • 13.5.3 为什么要定义这么多迭代器
        • 13.5.4 容器中定义的迭代器类型与5种类型的对应
        • 13.5.5 流迭代器
        • 13.5.6 迭代器失效
      • 13.6 泛型算法
        • 13.6.2 算法分类
      • 13.7 适配器
        • 13.7.2 迭代器适配器
        • 13.7.3 函数适配器
      • 13.8 小结
    • 12.3 类模板
      • 12.3.2 隐式实例化
      • 12.3.3 显式实例化
      • 12.3.4 显式特化
      • 12.3.5 部分特化
      • 12.3.6 重载和优先级
    • 12.4 模板的嵌套
      • 12.4.2 对象成员模板
    • 12.5 模板参数
    • 12.6 小结
  • 第五篇 输入输出处理和编程规范
    • 14.1.2 流
    • 14.2 高层I/O
      • 14.2.2 标准输入函数scanf
      • 14.2.3 扫描集
      • 14.2.4 sprintf和sscanf函数
      • 14.2.5 fprintf和fscanf函数
      • 14.2.6 文件访问机制
    • 第15章 名称空间
      • 15.1.2 定义名称空间
      • 15.2 实体的作用域与可见域
        • 15.2.2 可见域的扩展
        • 15.2.3 using声明机制
        • 15.2.4 using声明带来的多重声明问题(二义性)
        • 15.2.5 空间内的“屏蔽”
        • 15.2.6 先声明,后使用
      • 15.3 名称空间的作用域与可见性
        • 15.3.2 推荐用法
        • 15.3.3 名称空间嵌套
        • 15.3.4 using编译指令
        • 15.3.5 未命名的名称空间
      • 15.4 对名称空间的思考
      • 15.5 小结
    • 14.1.3 缓冲区
    • 14.3 流类库
      • 14.3.2 流类库层次
    • 第16章 异常和错误
      • 16.1.2 返回错误标志
      • 16.2 异常机制
        • 16.2.2 异常处理程序
        • 16.2.3 自定义异常对象
        • 16.2.4 有继承关系的类异常
        • 16.2.5 terminate函数和set_terminate函数
        • 16.2.6 unexpected函数与set_unexpected函数
        • 16.2.7 标准异常
        • 16.2.8 对unexpected函数的补充
      • 16.3 异常发生时的内存管理
        • 16.3.2 异常处理机制和函数的不同
        • 16.3.3 构造函数中抛出异常
        • 16.3.4 内存泄露
        • 16.3.5 析构函数中可否抛出异常
      • 16.4 auto_ptr类
        • 16.4.2 关于auto_ptr的若干问题
      • 16.5 小结
    • 14.1.4 重定向
    • 14.4 输出流
      • 14.4.2 其他ostream方法
      • 14.4.3 格式状态字
      • 14.4.4 格式控制值的默认值
      • 14.4.5 flag()函数读取和设定格式状态字
      • 14.4.6 使用setf函数和unsetf函数设定格式关键字
      • 14.4.7 设置域宽
      • 14.4.8 填充字符
      • 14.4.9 浮点数输出和显示精度
      • 14.4.10 控制符
    • 第17章 RTTI和类型转换操作符
      • 17.1.2 typeinfo类和typeid操作符
      • 17.2 类型转换操作符
        • 17.2.2 static_cast操作符
        • 17.2.3 reinterpret_cast操作符
      • 17.1.3 补充说明
      • 17.3 小结
    • 14.1.5 3种输入输出机制
    • 14.5 输入流
      • 14.5.2 输入流与格式状态字
      • 14.5.3 输入流与域宽
      • 14.5.4 使用get函数读取单个字符
      • 14.5.5 使用get和getline函数读取C风格字符串
      • 14.5.6 其他istream方法
    • 第18章 string类
      • 18.2 声明一个字符串
      • 18.3 字符串的输入输出
      • 18.4 string类功能
        • 18.4.2 赋值和清空
        • 18.4.3 元素删除
        • 18.4.4 元素追加与相加
        • 18.4.5 元素插入
        • 18.4.6 大小和容量
        • 18.4.7 元素存取
        • 18.4.8 字符串比较
        • 18.4.9 提取子串
        • 18.4.10 搜索与查找
      • 18.5 小结
    • 14.6 流状态
      • 14.6.2 读取流状态
      • 14.6.3 管理流状态
    • 第19章 编码风格
      • 19.1.2 空行的用法
      • 19.2 命名规则
        • 19.2.2 如何对程序实体命名
      • 19.1.3 代码行
      • 19.3 项目文件的组织
        • 19.3.2 头文件
        • 19.3.3 定义文件
        • 19.3.4 目录结构
      • 19.1.4 空格
      • 19.4 小结
      • 19.1.5 缩进与对齐
      • 19.1.6 &和*的位置
    • 14.7 重载>>和<<
      • 14.7.2 抽取符的重载
    • 第20章 程序编译
      • 20.2 预处理
        • 20.2.2 宏
        • 20.2.3 条件编译
        • 20.2.4 #ifdef、#ifndef与重复包含
        • 20.2.5 使用const代替#define定义常量
        • 20.2.6 inline与#define的比较
      • 20.3 VC6调试入门
        • 20.3.2 条件断点
        • 20.3.3 数据断点
        • 20.3.4 消息断点
        • 20.3.5 观察视图Watch
        • 20.3.6 内存视图Memory
        • 20.3.7 变量视图Variables
        • 20.3.8 寄存器视图Registers
        • 20.3.9 调用堆栈视图Call Stack
        • 20.3.10 反汇编视图Disassembly
        • 20.3.11 进程控制
      • 20.4 其他调试手段
        • 20.4.2 assert宏
        • 20.4.3 偷懒的办法:输出字符串
      • 20.5 小结
    • 14.8 文件操作
      • 14.8.2 文件的打开
      • 14.8.3 取消文件和流的关联
      • 14.8.4 文件的读写
      • 14.8.5 文本文件的读写
      • 14.8.6 二进制文件的读写
      • 14.8.7 文件定位指针和随机读取
    • 14.9 字符串流
      • 14.9.2 sstream类族
    • 14.10 小结
暂无相关搜索结果!
    展开/收起文章目录

    二维码

    手机扫一扫,轻松掌上学

    《零基础学C++》电子书下载

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

    书签列表

      阅读记录

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