零起点学通C++视频C++基础入门教程初学者必备

零起点学通C++视频C++基础入门教程初学者必备

全套教程约合3.8G！已经更新到第20章！
配带源码+PDF讲义
视频为高清swf格式！
目录：
第1章 初识C++

1.1 C++简介

1.2 C++与C的区别

1.3 学习C++之前需要先学C吗

1.4 C++与其他语言的区别

1.5 C++的版本以及安装问题



第2章 做一个最简短的C++程序

2.1 简单的屏幕输出小程序

2.2 输出语句的使用

2.3 std::介绍

2.4 iostream与iostream.h的区别

2.5 重名问题

2.6 注释



第3章 初步了解函数

3.1 一个简单的函数

3.2 函数的传参

3.3 函数的返回值. 参数与变量

3.4 函数的声明与定义

3.5 局部变量

3.6 全局变量



第4章 C++数据类型

4.1 变量的定义

4.2 将变量及数据存储在内存中

4.3 布尔型变量

4.4 字符型变量

4.5 wchar_t双字节型变量

4.6 整型概述

4.7 整型变量的定义

4.8 浮点型变量

4.9 常量

4.10 枚举型常量



第5章 if语句与逻辑运算符

5.1 语句的定义

5.2 块的定义

5.3 表达式的定义

5.4 运算符的定义

5.4.1 赋值运算符的定义

5.4.2 数学运算符的定义

5.4.3 赋值运算符与数学运算符的联合

5.5 自加与自减

5.5.1 前置

5.5.2 后置

5.6 表达式的优先级

5.7 关系运算符

5.8 if语句

5.8.1 else语句

5.8.2 else if语句

5.8.3 if语句的嵌套

5.9 逻辑运算符及其使用

5.9.1 逻辑“与”

5.9.2 逻辑“或”

5.9.3 逻辑“非”

5.9.4 逻辑运算符的优先级

5.9.5 运算式的真假关系

5.10 三目运算符

5.10.1 三目运算符的优先问题

5.10.2 三目运算符的使用问题

5.10.3 三目运算符的型别问题

5.10.4 三目运算符在字符型变量中的使用

5.11 复杂嵌套的if语句



第6章 面向对象

6.1 面向对象程序语言的主要特征

6.2 类. 对象和成员

6.3 类. 对象和成员的使用方法及区别

6.3.1 声明一个类

6.3.2 命名习惯

6.3.3 定义一个对象

6.3.4 类与对象的区别

6.3.5 对象与成员的关系

6.3.6 不要给类赋值

6.3.7 对象只能调用类中存在的成员

6.4 公有

6.5 私有

6.6 成员函数的声明和定义

6.7 为什么将成员函数的声明和定义分开

6.7.1 普通内联函数

6.7.2 成员内联函数

6.8 将类声明和定义部分保存在头文件中

6.9 const成员函数

6.10 构造函数

6.11 默认构造函数

6.12 析构函数

6.13 析构对象数组



第7章 循环语句

7.1 循环语句的前身——goto语句

7.2 慎用goto语句

7.3 while语句

7.3.1 带运算符的while语句

7.3.2 以字符为条件的while语句

7.3.3 限定while循环的次数

7.3.4 continue语句

7.3.5 break语句

7.3.6 永不休止的while循环

7.4 do… while循环

7.5 for循环

7.5.1 灵活的for循环

7.5.2 条件为空的for循环

7.5.3 执行为空的for循环

7.5.4 嵌套的for循环

7.6 switch语句

7.6.1 switch语句常见错误

7.6.2 switch的菜单功能

7.7 总结



第8章 指针

8.1 什么是地址

8.2 用指针来保存地址

8.2.1 空指针

8.2.2 指针与变量类型

8.2.3 用指针来访问值

8.2.4 指针地址. 指针保存的地址和该地址的值

8.2.5 指针对数值的操作

8.2.6 更换指针保存的地址

8.3 为什么使用指针

8.3.1 栈和堆

8.3.2 用指针创建堆中空间

8.3.3 用指针删除堆中空间

8.4 动态内存

8.4.1 内存泄漏

8.4.2 在堆中创建对象

8.4.3 在堆中删除对象

8.4.4 访问堆中的数据成员

8.4.5 在构造函数中开辟内存空间

8.4.6 对象在栈与堆中的不同

8.5 this指针

8.6 指针的常见错误

8.7 指针运算

8.7.1 指针的加减运算

8.7.2 指针的赋值运算

8.7.3 指针的相减运算

8.7.4 指针的比较运算

8.8 指针

8.8.1 常量指针

8.8.2 指向常量的指针

8.8.3 指向常量的常指针

8.9 总结



第9章 引用

9.1 什么是引用

9.1.1 引用的地址

9.1.2 引用就是别名常量

9.1.3 引用对象

9.1.4 空引用

9.2 函数的参数传递

9.2.1 通过值来传递函数参数

9.2.2 通过指针来传递函数参数

9.2.3 通过引用来传递函数参数

9.2.4 让函数返回多个值

9.3 传递对象

9.3.1 用值来传递对象

9.3.2 使用指针来传递对象

9.3.3 使用const指针来传递对象

9.3.4 使用引用来传递对象

9.3.5 到底是使用引用还是指针

9.3.6 引用和指针可以一块用

9.4 引用应注意的问题

9.4.1 引用容易犯的错误

9.4.2 引用一个按值返回的堆中对象

9.4.3 引用一个按别名返回的堆中对象

9.4.4 在哪里创建,就在哪里释放

9.5 总结



第10章 深入函数

10.1 函数重载

10.1.1 普通函数的重载

10.1.2 成员函数的重载

10.2 函数的默认参数

10.3 重载构造函数

10.3.1 成员变量的初始化

10.3.2 成员变量的初始化与构造函数

10.3.3 复制构造函数

10.3.4 构造函数和new运算符

10.3.5 再谈默认构造函数

10.4 析构函数和delete运算符

10.4.1 默认析构函数

10.4.2 调用构造函数进行类型转换

10.5 浅层复制构造函数

10.6 深层复制构造函数



第11章 运算符重载

11.1 运算符重载

11.2 在成员函数中实现自加

11.3 重载前置自加运算符

11.4 创建临时对象

11.5 创建无名临时对象

11.6 取消创建临时对象

11.7 重载后置自加运算符

11.8 重载加法运算函数operator+

11.9 重载赋值运算函数operator=

11.10 转换类型运算符

11.10.1 温习调用构造函数实现的类型转换

11.10.2 通过构造函数将变量转换为一个对象的成员变量

11.10.3 通过operator关键字进行转换

11.11 什么可以被重载,什么不可以



第12章 继承

12.1 什么是继承和派生

12.1.1 复杂的继承和派生

12.1.2 继承和派生如何在C++中实现

12.1.3 继承的种类及语法

12.1.4 单一继承

12.2 公有型. 保护型和私有型

12.3 访问权限

12.4 多重继承

12.5 继承的构造与析构

12.6 向基类构造函数传递参数

12.7 继承和重载的两义性问题

12.7.1 多重继承容易产生两义性

12.7.2 两义性在重载时的一些问题

12.7.3 两义性的归属问题

12.7.4 减少两义性产生的混淆问题

12.7.5 虚基类不会产生两义性

12.8 总结



第13章 虚函数

13.1 指向对象的指针

13.2 虚函数

13.3 拳击游戏

13.4 继承是否可以实现多态性

13.5 在编译时的静态联编

13.6 在运行时的静态联编

13.7 在编译时的动态联编

13.8 在运行时的动态联编

13.9 调用虚函数

13.9.1 在虚函数中调用成员函数

13.9.2 三种调用虚函数的方式比较

13.10 被继承的虚函数仍然是虚函数

13.11 系统是如何调用虚函数的

13.12 在虚函数中使用成员名限定

13.13 虚析构函数



第14章 数组

14.1 数组的基本用法

14.1.1 什么是数组

14.1.2 数组元素

14.1.3 数组下标越界

14.1.4 倒序输出

14.1.5 将数组的下标定义为常量

14.1.6 手动操作数组元素

14.1.7 数组的初始化

14.2 数组的用途

14.2.1 求平均考试成绩

14.2.2 兔子繁殖问题

14.2.3 数字排序问题

14.3 数组在内存中的分布

14.4 输出数组名

14.5 数组名与函数

14.6 传递与接收

14.7 数组与函数

14.7.1 函数传参实例一——求数组所有元素的和

14.7.2 函数传参实例二——用递增法查找数据

14.7.3 函数传参实例三——用二分法查找数据

14.7.4 函数传参实例四——判断数组是否按照顺序排列

14.7.5 函数传参实例五——判断数组排列方式后执行不同的函数

14.8 数组在对象中的传参

14.9 数组对象

14.10 在数组对象中初始化成员变量

14.11 指针数组

14.12 枚举常量与数组..

14.13 多维数组

14.14 多维数组的初始化

14.15 字符数组

14.16 重载数组下标操作符



第15章 链表

15.1 声明链表结构

15.2 简单的图书链表

15.2.1 图书链表

15.2.2 类的链表

15.3 动态链表

15.3.1 动态链表的建立

15.3.2 解决输入字符造成死循环的问题

15.3.3 动态链表的显示

15.3.4 动态链表的删除

15.3.5 动态链表的插入

15.3.6 链表统计

15.3.7 使用链表

15.4 完整的动态链表清单

15.5 链表使用案例——走迷宫

15.5.1 创建Windows应用程序项目

15.5.2 创建窗口

15.5.3 加载图片

15.5.4 句柄是什么

15.5.5 显示图片

15.5.6 动画

15.5.7 键盘控制人物移动

15.5.8 迷宫墙壁

15.5.9 走迷宫

15.5.10 用链表记录行走路线



第16章 多态性

16.1 为什么要使用多重继承

16.2 在派生类中增加函数

16.3 使用多重继承

16.4 多重继承中初始化构造函数的参数

16.5 多个子基类共享一个父基类

16.6 虚基类

16.7 慎用多重继承

16.8 空的虚函数

16.9 抽象类和纯虚函数

16.10 纯虚函数

16.11 复杂的抽象结构



第17章 类的特殊成员

17.1 静态成员变量

17.2 私有静态成员变量

17.3 静态成员函数

17.4 静态成员的使用

17.5 函数指针

17.6 函数指针数组

17.7 函数指针也可以作为函数的参数

17.8 使用typedef简化函数指针的声明及定义

17.9 类的函数指针

17.10 成员函数指针数组



第18章 字符串

18.1 char型字符串

18.2 string型字符串

18.2.1 string型字符串的赋值

18.2.2 string型字符串的合并

18.2.3 string型字符串的部分合并

18.2.4 string型字符串的替换

18.2.5 string型字符串的复制

18.2.6 string型字符串的插入

18.2.7 string型字符串的删除

18.2.8 string型字符串的查找

18.2.9 string型字符串的比较

18.2.10 判断string型字符串是否为空

18.3 字符串的使用

18.3.1 swap() 交换两个字符串的内容

18.3.2 将string型字符串转为char型字符串

18.3.3 char型字符串与函数

18.3.4 函数如何返回字符串

18.4 结构体

18.4.1 结构体的赋值

18.4.2 结构体与函数

18.4.3 结构体与string

18.5 string数组与函数

18.6 流的使用

18.6.1 重载输出运算符<<

18.6.2 友元的方式重载输出运算符

18.6.3 重载自加运算符的执行次序

18.6.4 重载输入运算符>>

18.7 编写一个String类

18.7.1 创建String类

18.7.2 创建可自动调节大小的String类字符串对象

18.7.3 限制数组越界

18.7.4 用复制构造函数实现字符串的赋值功能

18.7.5 用重载赋值运算符函数实现真正的字符串赋值功能

18.7.6 用重载输出运算符operator<<()函数实现字符串的输出

18.7.7 用重载输入运算符operator>>()函数实现字符串的输入

18.7.8 用重载比较运算符实现字符串的比较

18.7.9 为String类添加字符串的相加功能

18.7.10 为String类添加字符串的+=功能

18.7.11 完成后的String类



第19章 代码重用

19.1 包含

19.2 将String类作为包含类

19.3 为book类重载执行相加运算的成员函数

19.4 包含对系统造成的消耗

19.5 按别名传递book对象

19.6 包含指向另一个类的指针

19.6.1 数据类Date

19.6.2 链表类Node

19.6.3 标签类linkelist

19.6.4 头节点类HeadNode

19.6.5 尾节点TailNode类

19.6.6 中间节点InterNode类

19.6.7 InterNode类的构造函数

19.6.8 InterNode类的插入函数

19.6.9 全部程序

19.7 将头节点. 中间节点和尾节点合并为一个节点

19.7.1 数据类Date

19.7.2 由Date类派生的图书类Book

19.7.3 由Date类派生的药品类medica

19.7.4 创建一个节点类Node

19.7.5 用来操作节点类Node的list类

19.7.6 list类的getfirst()方法

19.7.7 list类的operator[]方法

19.7.8 list类的repeat()方法

19.7.9 list类的insert()方法

19.7.10 list类的find()方法

19.7.11 重写的药品管理全部程序

19.8 利用类的包含来实现代码重用

19.9 私有继承

19.10 什么时候使用私有继承,什么时候使用包含

19.11 保护继承