C++概述2

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
     *  【继承】
     *      <类重用的思想>
     *          组合、继承
     *
     *      <what>
     *              保持已有类的特性 而 构造新类的过程；
     *
     *              继承与派生
     *                  在新类角度：
     *                      新类继承了哪些已有类；
     *                  在已有类角度：
     *                      从已有类派生了哪些新类；
     *
     *              基类与派生类
     *                  被继承的已有类 称为基类（父类）；
     *              派生类
     *                  派生出的新类；
     *
     *              继承的目的：
     *                  实现代码（设计）重用；
     *              派生的目的：
     *                  当新的问题出现，原有程序无法解决（或不能完全解决）时，需要对原有程序进行改造；
     *
     *      <派生类的声明>
     *          class 派生类名 : 访问修饰符 基类名
     *          {
     *              成员
     *          }
     *
     *          *** C++支持多继承
     *
     *      <继承的逻辑关系>
     *          is a
     *          *** 当继承与组合均允许的情况下，首选组合；
     *
     *      <派生类生成过程>
     *          吸收基类成员
     *          改造基类成员
     *          添加新的成员
     *
     */

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/**
     *  【多态】
     *      <what>
     *          当类存在继承关系时，会根据调用函数的对象的类型来执行不同的函数。
     *
     *      <分类>
     *          绑定：
     *              把一个标识符名 与 一个存储地址 联系在一起的过程；
     *
     *          按 实现的时机：
     *              编译时多态
     *                  绑定工作在编译连接阶段完成；
     *                      eg：方法重载
     *              运行时多态
     *                  绑定工作在运行期间完成；
     *                      eg：方法重写
     *
     *      <运算符重载>
     *          对 已有的运算符 赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为；
     *
     *          2种重载方式：
     *              重载为类的非静态成员函数
     *              重载为类的非成员函数
     *
     *          声明：
     *              函数类型 operator运算符（形参）
     *              {
     *                  ...
     *              }
     *
     *      <虚函数>
     *          what
     *              在基类中使用关键字 virtual 声明的函数；
     *          作用
     *              在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。
     *              ***
     *                  为每个具有虚函数的类，准备了一张虚函数表；
     *                  当某个类中有虚函数，编译器为这个类的对象的数据成员增加一个隐含的数据成员（指向虚函数表的指针）；
     *                  运行时可以根据实际类型找到对应的函数；
     *          声明：
     *              virtual 函数类型 函数名(形参列表)
     *              {
     *                  ...
     *              }
     *
     *          纯虚函数：
     *              what
     *                  在一个基类中声明的虚函数，在基类中没有具体的实现内容，由派生类根据实际需要定义自己的版本；
     *              声明：
     *                  class 类名
     *                  {
     *                      virtual 类型 函数名（参数列表）= 0;
     *                  }
     *
     */

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
     *  【模板】
     *      <函数模板>
     *          作用
     *              创建一个通用功能的函数，以支持多种不同形参；
     *          声明
     *              template <typename 类型>
     *              函数声明
     *          原理
     *              编译器 根据 实际参数类型及函数模板 反推，重新生成一个新的函数；
     *
     *      <类模板>
     *          作用
     *              使用类模板 使用户可以为类声明一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值，能取任意类型；
     *          声明
     *              template <class type> class class-name {...}
     *          原理
     *              编译器 根据 实际模板的参数类型，生成完整的类的代码；
     *
     *      ***
     *          C++采用的是类型生成机制：
     *              根据模板生成代码
     */

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/**
     *  【群体】
     *      what
     *          由多个数据元素组成的集合体；
     *      分类
     *          线性群体、非线性群体
     *
     *      <线性群体>
     *          what
     *              线性群体中的元素 按位置排列有序；
     *
     *          线性群体的不同访问方法
     *              1、直接访问
     *                  无需按顺序依次访问
     *
     *                  直接访问群体->数组
     *                      静态数组：
     *                          具有固定元素个数的群体，其中的元素可以通过下标直接访问；
     *                          （缺点：大小在编译时已经确定，运行时无法修改）
     *                      动态数组：
     *                          由一系列位置连续的，任意数量相同类型的元素组成；
     *                          （优点：元素个数在运行时可改变、缺点：开销大）
     *
     *                      逻辑相邻关系 与 物理相邻关系 对应，对数组元素进行更新时，需要顺序移动；
     *
     *              2、顺序访问
     *                  必须按顺序依次访问
     *
     *                  顺序访问群体->链表
     *                      what
     *                          动态数据结构；
     *                          由结点组成，结点运行时动态生成，每个结点要存储 数据本身+下一个结点的存储地址；
     *                          逻辑上的相邻关系 不依赖 物理上的相邻关系；
     *
     *
     *              索引访问
     *
     *          特殊的线性群体
     *              1、栈
     *                  what
     *                      只能从一端操作的线性群体；
     *                      可以访问的一端称栈顶，另一端称栈底；
     *                  作用
     *                      处理表达式
     *                  基本状态
     *                      栈空、栈满、一般状态
     *
     *              2、队列
     *                  what
     *                      只能一端添加，另一端删除元素的线性群体；
     *                  状态
     *                      队空、队满、一般状态
     *
     *
     *     <非线性群体>
     *         what
     *              数据元素 不依赖位置顺序 来标识元素；
     *
     *     <群体数据的组织>
     *          排序
     *              what
     *                  将计算机的一系列数据 按照某种规则 排成有序的；
     *              排序的2个基本操作：
     *                  比较；
     *                  交换；
     *              分类
     *                  内部排序
     *                      全部数据在内存中排序
     *                  外部排序
     *                      当数据量很大时，需要将磁盘数据一部分加载到内存进行排序
     *          查找
     *              无序数据
     *                  只能顺序查找；
     *              有序数据
     *                  二分查找...
     *
     */

　　

?
1
2
3
4
5
6
/**
     *  【泛型程序设计】
     *      what
     *          将算法从特定的数据结构中抽象处理，称为通用的；
     *          编写不依赖于具体数据类型的程序；
     */

　　

posted on   anpeiyong  阅读(34)  评论(0)  编辑  收藏  举报

相关博文：
· C++概述1
· JVM---概述
· C++ 复习
· C++继承和派生
· C++ 基础梳理不完整总结
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· .NET10 - 预览版1新功能体验（一）
历史上的今天：
2021-04-14 《计算机网络原理-西安交通大学》---广域网
2020-04-14 JavaSE---内存分配
2020-04-14 JavaSE---GC
2020-04-14 JavaSE---引用

导航

< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛