21天学C++ 概览

目录:

一、概述
    1.1 面向过程和面向对象
        1.1.1 面向过程
        1.1.2 面向对象
        1.1.3 关系
    1.2 开发C++程序步骤
        1.2.1 利用Microsoft Visual Studio 2008创建项目
        1.2.2 在项目中添加文件
        1.2.3 iostream.h和iostream区别
    1.3 编写、编译、链接、运行C++程序
        1.3.1 编译
        1.3.2 链接
        1.3.3 运行
        
二、C++程序的组成部分
    2.1 一个简单的程序
    2.2 count简介
    2.3 标准Namespace
        2.3.1 告诉编译器使用标准库函数cout和endl
        2.3.2 使用全部namespace标准
    2.4 注释
        2.4.1 注释类型
        2.4.2 使用注释
    2.5 函数
        2.5.1 函数的组成:函数头(返回类型、函数名、参数)+函数体
        
三、变量和常量
    3.1 什么是变量
        3.1.1 数据存于内存
        3.1.2 变量大小
        3.1.3 有符号和无符号
    3.2 操作变量
        3.2.1 定义变量
        3.2.2 一次创建多个变量
        3.2.3 变量初始化、赋值
        3.2.4 typedef
        3.2.5 无符号和有符号的回绕
        3.2.6 字符型变量
        3.2.7 转义字符
        3.2.8 定义变量注意事项
        3.2.9 关键字
    3.3 常量
    
四、表达式和语句
    4.1 语句
        4.1.1 空白
        4.1.2 块,也称符合语句{}
    4.2 表达式
    4.3 运算符
    4.4 自加与自减
    4.5 优先级
    4.6 括号的嵌套
    4.7 真值bool
        4.7.1 关系运算符
    4.8 if…else
        4.8.1 if语句
        4.8.2 if…else 语句
        4.8.3 if 语句嵌套
    4.9 逻辑运算符
        4.9.1 逻辑运算符
        4.9.2 逻辑“与”,符号为&&
        4.9.3 逻辑“或”,符号为||
        4.9.4 逻辑“非”,符号为!
    4.10 条件运算符(三目运算符)
    
五、函数
    5.1 声明和定义函数
        5.1.1 全局函数
        5.1.2 函数原型
        5.1.3 函数声明
        5.1.4 函数定义
        5.1.5 函数返回值
        5.1.6 函数执行
        5.1.7 建议
    5.2 局部、全局变量
        5.2.1 局部变量
        5.2.2 全局变量
    5.3 默认参数
    5.4 函数重载
        5.4.1 函数重载
        5.4.2 用途
    5.5 内嵌函数
    5.6 递归
        5.6.1 递归:函数调用本身
        5.6.2 使用递归调用过程
        5.6.3 递归的返回过程
    5.7 函数的调用过程(可选)
        5.7.1 C++划分内存
        5.7.2 堆和栈区别
        
六、面向对象编程
    6.1 类和对象
        6.1.1 创建变量
        6.1.2 类
        6.1.3 声明一个类: Cat
        6.1.4 定义一个对象
        6.1.5 类和对象的关系
    6.2 访问类
        6.2.1 访问类成员
        6.2.2 给对象赋值,而不能给类型赋值
        6.2.3 私有private和公有public
        6.2.4 成员数据私有
        6.2.5 私有性与安全性
    6.3 实现类方法
    6.4 实现类方法
        6.4.1 类初始化
        6.4.2 类初始化
        6.4.3 类初始化
        6.4.4 类初始化
        6.4.5 所有对象都必须构造和析构
    6.5 成员函数const
    6.6 *.h *.cpp
    6.7 内联函数
        6.7.1 方法1:在返回类型前添加inline关键字
        6.7.2 方法2:将函数定义放到类声明中
    6.8 类作为成员变量
    6.9 struct
    
七、程序流程
    7.1 goto循环
    7.2 while循环
    7.3 continue break
    7.4 do…while
    7.5 for循环
        7.5.1 语句格式
        7.5.2 多重初始化和自增运算
        7.5.3 for循环中使用空语句
        7.5.4 空for循环
        7.5.5 嵌套循环
        7.5.6 for的作用域
        7.5.7 使用for循环实现Fibonacci数列
    7.6 switch语句
    
八、指针
    8.1 指针
        8.1.1 指针是保存内存地址的变量
        8.1.2 声明指针变量
        8.1.3 指针大小
        8.1.4 间接指针(*)
        8.1.5 使用指针操作变量
    8.2 栈和自由存储区(堆)
        8.2.1 栈
        8.2.2 new
        8.2.3 delete
        8.2.4 内存泄漏情形一
        8.2.5 内存泄漏情形二
    8.3 堆中类的使用
        8.3.1 在自由存储区创建对象
        8.3.2 删除对象
        8.3.3 访问数据成员
        8.3.4 堆中的成员数据
    8.4 this
    8.5 迷途指针
    8.6 const 指针
    8.7 指针主要用途
    
九、引用
    9.1 引用
        9.1.1 引用就是一个别名
        9.1.2 格式
        9.1.3 引用运算符&和去地址运算符号相同,但不是同一个运算符
        9.1.4 给引用重新赋值
        9.1.5 什么可以被引用
        9.1.6 空指针和空引用
    9.2 引用/指针传递和返回
        9.2.1 使用指针递,使用引用传递
        9.2.2 返回多个值
        9.2.3 提高传递效率
        9.2.4 const引用/指针
    9.3 引用/指针使用事项
        9.3.1 何时使用引用、何时使用指针
        9.3.2 不要返回对不在作用域中的对象的引用
        9.3.3 返回堆中的对象
    
十、高级函数
    10.1 成员函数重载、默认值
        10.1.1 成员函数重载
        10.1.2 成员函数默认值
        10.1.3 默认值和重载函数如何选择
    10.2 默认、重载、复制构造函数
        10.2.1 默认构造函数
        10.2.2 重载构造函数
        10.2.3 初始化对象
        10.2.4 复制构造函数
    10.3 运算符重载
        10.3.1 重载前置运算符
        10.3.2 重载后置运算符
        10.3.3 重载加法运算符
        10.3.4 重载赋值运算符
    10.4 装箱、拆箱
        10.4.1 装箱
        10.4.2 拆箱
    
十二、继承
    12.1 继承和派生
        12.1.1 继承和派生
        12.1.2 格式/语法
        12.1.3 public、private、protected访问可见性
        12.1.4 实例
    12.2 构造函数和析构函数
        12.2.1 调用顺序
        12.2.2 向基类构造函数传递参数
    12.3 覆盖函数
        12.3.1 函数覆盖
        12.3.2 隐藏基类方法
        12.3.3 调用基方法
    12.4 虚函数
        12.4.1 C++扩展其多态性,允许把派生类对象赋给指向基类的指针
        12.4.2 动态编译
        12.4.3 不能从基类访问派生类中的函数
        12.4.4 slicing切片  
    12.5 虚析构函数
    12.6 虚复制构造函数
    
十三、数组和链表
    13.1 数组
        13.1.1 数组
        13.1.2 数组初始化
        13.1.3 对象数组
        13.1.4 多维数组
        13.1.5 多维数组初始化,如inttheArray[5][3]
    13.2 指针数组
        13.2.1 指针数组
        13.2.1 指向数组的指针和指针数组
    13.3 char数组
    13.4 strcpy()和strncpy()
        13.4.1 strcpy()
        13.4.2 strncpy()
    13.5 字符串类
    13.6 链表
    
十四、多态性
    14.1 单一继承问题
        14.1.1 升迁
        14.1.2 下降
    14.2 多重继承
        14.2.1 多重继承:从多个基类中派生一个新类
        14.2.2 多重继承构造函数初始化
        14.2.3 歧义解析1
        14.2.4 歧义解析2
        14.2.5 虚继承
        14.2.6 多重继承存在的问题
    14.3 抽象数据类型
        14.3.1 纯虚函数
        14.3.2 实现纯虚函数
    
十五、特殊类和函数
    15.1 静态成员变量
        15.1.1 静态成员变量:一个类的所有实例中共享
        15.1.2 静态成员变量限制访问
    15.2 静态成员函数
    15.3 函数指针
        15.3.1 函数指针
        15.3.2 函数指针数组
    
十六、高级继承
    16.1 包容
        16.1.2 按值和按引用传递
    16.2 私有继承
    16.3 友元
        16.3.1 友元类
        16.3.2 友元函数1
        16.3.3 友元函数2(常用:重载运算符)
        16.3.4 重载插入运算符 <<
    
十七、流
    17.1 标准I/0对象
        17.1.1 流和缓冲区
    17.2 cin
        17.2.1 cin输入:处理来自标准输入设备(键盘)的输入
        17.2.2 cin输入串
        17.2.3 单字符输入:char c = cin.get();
        17.2.4 单字符输入:char c = cin.get(a);
        17.2.5 读取字符串:
        17.2.7 vignore()、peek()、putback()
    17.3 cout
        17.3.1 cout
        17.3.2 cout.put()
        17.3.3 cout.write(字符数组指针,输出最大字符数)
        17.3.4 cout.width(宽度);count.fill(char)
    17.4 printf
    17.5 文件的输入输出 ifstream ofstream
        17.5.1 利用ofstream打开文件,修改默认行为
    17.6 命令行处理
    
十八、名字空间
    18.1 名字冲突
        18.1.1 名字空间
        18.1.2 隐藏
        18.1.3 可见性
    18.2 名字空间
        18.2.1 创建名字空间
        18.2.2 名字空间的访问
        18.2.3 嵌套名字空间的访问
        18.2.4 类嵌套
    18.3 关键字using
        18.3.1 using 命令
        18.3.2 using 声明
    18.4 命名空间别名
    18.5 标准名字空间std
    
十九、模板
    19.1 模板的定义和实现
    19.2 模板函数
    19.3 C++ STL
        19.3.1 标准模板库 STL
        19.3.2 容器
        19.3.3 常用顺序容器:vector
        19.3.4 常用顺序容器:如list
        19.3.5 堆栈:如stack:后进先出
        19.3.6 队列:如stack:先进先出
        19.3.7 关联容器     
    19.4 算法类
    
二十、异常和错误处理
    20.1 程序中的各种错误
    20.2 异常
        20.2.1 异常的使用
        20.2.2 捕获异常
    
二一、进一步掌握的内容
    21.1 预处理和预编译
        21.1.1 #include:运行编译时,预处理器先运行
        21.1.2 #define:定义字符串替换,如#define BIG 512
        21.1.3 编译器预定义了大量有用的宏,如_DATE_、_TIME_等两条下划线
        21.1.4 #ifdef      #ifndef    #endif
        21.1.5 避免头文件重复包含
    21.2 宏函数
    21.3 内联函数inline
    21.4 assert()
    21.5 打印中间值DEBUG

发表回复