面向对象程序设计课堂笔记

Lecture 1

程序设计范型是指设计程序的规范、模型和风格,它是一类程序设计语言的基础。

  • 面向过程程序设计范型:程序=过程+调用 或 程序=算法+数据结构
  • 函数式程序设计范型:程序被看作“描述输入与输出之间关系”的数学函数。如LISP
  • 面向对象程序设计是一种新型的程序设计范型。这种范型的主要特征是:对象=(算法+数据结构)程序=对象+消息

面向对象程序的主要结构特点:
一、程序一般由类的定义类的使用两部分组成,在主程序中定义各对象并规定它们之间传递消息的规律。
二、程序中的一切操作都是通过向对象发送消息来实现的,对象接收到消息后,启动有关方法完成相应的操作。

基本概念

  • 对象 Object
  • 类 Class
  • 消息 Message
  • 方法 Method

对象

在现实世界中,任何事物都是对象。可以使有形的具体存在的事物,也可以是无形的抽象的事件。
对象一般可以表示为:属性+行为
(单独的可以缺属性只定义行为,整个体系则缺一不可)

名字:用于区别不同的实体
属性/状态:属性用于描述不同实体的特征状态由这个对象的属性和这些属性的当前值决定。
操作:用于描述不同实体可具有的行为是对象提供给用户的一种服务,也叫行为或方法。
· 对象的操作可以分为两类,一类是自身所承受的操作(private/protected),一类是施加于其他对象的操作(public)。

方法(Method)——就是对象所能执行的操作,即服务。方法描述了对象执行操作的算法,响应消息的方法。在C++中称为成员函数
属性(Attribute)——就是类中所定义的数据,它是对客观世界实体所具有性质的抽象。C++中称为数据成员

在面向对象程序设计中,对象是描述其属性的数据及对这些数据施加的一组操作封装在一起构成的统一体
对象可以认为是:数据+方法(操作)

在现实世界中,是一组具有相同属性行为的对象的抽象。
对象之间的关系式抽象具体的关系。类是多个对象进行综合抽象的结果,一个对象是类的一个实例。
在面向对象程序设计中,类就是具有相同数据和相同操作的一组对象的集合。是对具有相同数据结构和相同操作的一类对象的描述。
在面向对象程序设计中,总是先声明类,再由类生成其对象。

注意不能把一组函数组合在一起构成类。即类不是函数的集合。

消息

面向对象设计技术必须提供一种机制允许一个对象与另一个对象的交互,这种机制叫消息传递
在面向对象程序设计中,一个对象向另一个对象发出的请求被称为消息。当对象收到消息时,就调用有关的方法,执行相应的操作。消息是一个对象要求另一个对象执行某个操作的规格说明,通过消息传递才能完成对象之间的相互请求或相互协作。
消息具有三个性质:
(1).同一个对象可以接收不同形式的多个消息,作出不同的响应
(2).相同形式的消息可以传递给不同的对象,所作出的响应可以是不同的。
(3).对消息的响应并不是必需的,对象可以响应消息,也可以不响应。
分为两类:公有消息(其他对象发出),私有消息(向自己发出)。

方法

方法就是对象所能执行的操作。方法包括界面和方法体两部分。
方法的界面就是消息的模式,它给出了方法调用的协议;
方法体则是实现某种操作的一系列计算步骤,就是一段程序
在C++语言中方法是通过函数来实现的,称为成员函数
消息和方法的关系是:对象根据接收到的消息,调用相应的方法;反过来,有了方法,对象才能响应相应的消息。

面向对象程序设计的基本特征

  • 抽象 Abstraction
  • 封装 Encapsulation
  • 继承 Inheritance
  • 多态 Polymorphism

抽象

抽象是通过特定的实例(对象)抽取共同性质以后形成概念的过程。抽象是对系统的简化描述和规范说明,他强调了系统中的一部分细节和特性,而忽略了其他部分
抽象包括两个方面,数据抽象代码抽象(或称行为抽象)。前者描述某类对象的属性和状况,也就是此类对象区别于彼类对象的特征物理量;后者描述了某类对象的共同行为特征或具有的共同操作。
在面向对象的程序设计方法中,对一个具体问题的抽象分析结果,是通过描述和实现的。

封装

在面向对象程序设计中,封装是指把数据和实现操作的代码集中起来放在对象内部,并尽可能隐藏对象的内部细节。
封装应该具有如下几个条件:
(1)对象具有一个清晰的边界,对象的私有数据和实现操作的代码被封装在该边界内。
(2)具有一个描述对象与其他对象如何相互作用的接口,该接口必须说明消息如何传递的使用方法。
(3)对象内部的代码和数据应受到保护,其他对象不能直接修改。

继承

继承是在一个已经建立的类的基础上再接着声明一个新类的扩展机制,原先已经建立的类称为基类,在基类之下扩展的类称为派生类,派生类又可以向下充当继续扩展的基类,因此构成层层派生的一个动态扩展过程。
派生类享有基类的数据结构和算法,而本身又具有增加的行为和特性,因此继承的机制促进了程序代码的可重用性。
一个基类可以有多个派生类,一个派生类反过来可以具有多个基类,形成复杂的继承树层次体系

基类与派生类之间本质的关系:基类是一个简单的类,描述相对简单的事物,派生类是一个复杂些的类,处理相对复杂的现象。

继承的作用:
避免公用代码的重复开发,减少代码和数据冗余。
通过增强一致性来减少模块间的接口。
继承分为单继承和多继承。

多态

多态性是指不同的对象收到相同的消息时产生多种不同的行为方式
C++支持两种多态性:编译时的多态性(重载)和运行时的多态性(虚函数)。

为什么要使用OOP
传统程序设计方法的局限性
(1)传统程序设计开发软件的生产效率低下
存在重用性复杂性可维护问题。(OOP三大优势)
(2)传统程序设计难以应付日益庞大的信息量和多样的信息类型
当代计算机所处理的数据已从最简单的数据和字符发展为多种格式的多媒体数据,如文本、图形、图像、影像、声音等。面对庞大的信息量和多样的信息格式,传统程序设计无法应付。
(3)传统的程序设计难以适应各种新环境
并行处理、分布式、网络和多机系统等节点之间的通信机制传统的程序设计技术很难处理。

OOP的主要优点
(1)可提高程序的重用性
(2)可控制程序的复杂性
(3)可改善程序的可维护性
(4)能够更好地支持大型程序设计
(5)增强了计算机处理信息的范围
(6)能很好地适应新的硬件环境

C++的优点
C++继承了C的优点,并有自己的特点,主要有:
(1)全面兼容C,C的许多代码不经修改就可以为C++所用,用C编写的库函数和实用软件可以用于C++。
(2)用C++编写的程序可读性更好,代码结构更为合理,可直接在程序中映射问题空间结构。
(3)生成代码的质量高,运行效率高。
(4)从开发时间、费用到形成软件的可重用性、可扩充性、可维护性和可靠性等方面有了很大提高,使得大中型的程序开发项目变得容易得多。
(5)支持面向对象的机制,可方便地构造出模拟现实问题的实体和操作。

C++对C的补充

注释与续行

注释符:/* *///
续行符:\。当一个语句太长时可以用该符号分段写在几行中
note: 其实不加续航符直接换行也可以0.0
E.g.

1
2
3
4
5
6
7
8
9
#include<iostream>
using namespace std;
int main() {
cout << "hello "
<< "world"
<< endl;
return 0;

This program will print hello world in a line.

输入输出流

C: scanfprintf
C++: cin>>cout<<(用C的也可以,但是不推荐……)
cout和cin分别是C++的标准输出流和输入流。C++支持重定向,但一般cout指的是屏幕,cin指的是键盘。操作符<<>>除了具有C语言中定义的左移和右移的功能外,在这里符号<<是把右方的参数写到标准输出流cout中;相反,符号>>则是将标准输入流的数据赋给右方的变量。
cin和>>,cout和<<配套使用
使用cout和cin时,也可以对输入和输出的格式进行控制,比如可用不同的进制方式显示数据,只要设置转换基数的操作符dec、hex和oct即可。

灵活的变量说明

定义变量的位置
在程序中的不同位置采用不同的变量定义方式,决定了该变量具有不同的特点。变量的定义一般可由以下三种位置:
(1)函数体内部
在函数体内部定义的变量称为局部变量。
(2)形式参数
当定义一个有参函数时,函数名后面括号内的变量,统称为形式参数。
(3)全局变量:在所有函数体外部定义的变量,其作用范围是整个程序,并在整个程序运行期间有效。

在C语言中,全局变量声明必须在任何函数之前,局部变量必须集中在可执行语句之前。
C++中的变量声明非常灵活。它允许变量声明与可执行语句交替执行,随时声明。for (int i = 0; i < 10; i++)

结构、联合和枚举名

在C++中,结构名、联合名、枚举名都是类型名。在定义变量时,不必在结构名、联合名或枚举名前冠以struct、union或enum。
如:定义枚举类型boole: enum boole{FALSE, TRUE};
在C语言中定义变量需写成enum boole done;,但在C++中,可以说明为boole done;

函数原型

C语言建议编程者为程序中的每一个函数建立圆形,而C++要求为每一个函数建立原型,以说明函数的名称、参数类型与个数,以及函数返回值的类型。其主要目的是让C++编译程序进行类型检查,即形参与实参的类型匹配检查,以及返回值是否与原型相符,以维护程序的正确性。
在程序中,要求一个函数的原型出现在该函数的调用语句之前。说明:
(1)函数原型的参数表中可不包含参数的名字,而只包含它们的类型。例如long Area(int, int);
(2)函数定义由函数首部和函数体构成。函数首部和函数原型基本一样,但函数首部中的参数必须给出名字而且不包含结尾的分号。
(3)C++的参数说明必须放在函数说明后的括号内,不可将函数参数说明放在函数首部和函数体之间。这种方法只在C中成立。
(4)主函数不必进行原型说明,因为它被看成自动说明原型的函数。
(5)原型说明中没有指定返回类型的函数(包括主函数main),C++默认该函数的返回类型是int。
(6)如果一个函数没有返回值,则必须在函数原型中注明返回类型为void,主函数类似处理。
(7)如果函数原型中未注明参数,C++假定该函数的参数表为空(void)。

const修饰符

C语言中习惯用#define定义常量,C++利用const定义正规常数
一般格式 const 数据类型标识符 常数名 = 常量值
采用这种方式定义的常量是类型化的,它有地址,可以用指针指向这个值,但不能修改它。
const必须放在被修饰类型符和类型名前面。
数据类型是可选项,用来指定常数值的数据类型,如果省略了数据类型,那么默认是int。
const的作用于#define相似,但它消除了#define的不安全性。

const可以与指针一起使用。
指向常量的指针、常指针和指向常量的常指针。
1)指向常量的指针是指:一个指向常量的指针变量。
2)常指针是指:把指针本身,而不是它指向的对象声明为常量。
3)指向常量的常指针是指:这个指针本身不能改变,它所指向的值也不能改变。要声明一个指向常量的常指针,二者都要声明为const。

说明:
(1)如果用const定义的是一个整型变量,关键词int可以省略
(2)常量一旦被建立,在程序的任何地方都不能再更改
(3)与#define定义的常量有所不同,const定义的常量可以有自己的数据类型,这样C++的编译程序可以进行更加严格的类型检查,具有良好的编译时的检测性。
(4)函数参数也可以用const说明,用于保证实参在该函数内部不被改动。

void型指针

void通常表示无值,但将void作为指针的类型时,它却表示不确定的类型。这种void型指针是一种通用型指针,也就是说任何类型的指针值都可以赋给void类型的指针变量。
void型指针可以接受任何类型的指针的赋值,但对已获值的void型指针,对它在进行处理,如输出或传递指针值时,则必须进行强制类型转换,否则会出错。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
int main() {
void *pc;
int i = 456;
char c = 'a';
pc = &i;
cout << *(int *)pc << endl;
pc = &c;
cout << *(char *)pc << endl;
return 0;
}

内联函数

调用函数时系统要付出一定的开销,用于信息入栈出栈和参数传递等。
C++引进了内联函数(inline function)的概念。在进行程序的编译时,编译器将内联函数的目标代码作拷贝并将其插入到调用内联函数的地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
using namespace std;
inline double circle(double r) {
return 3.1416 * r * r;
}
int main() {
for (int i = 0; i < 3; ++i) {
cout << "r = " << i << " area = " << circle(i) << endl;
}
return 0;
}

说明:
(1)内联函数在第一次被调用前必须进行声明或定义。否则编译器无法知道应该插入什么代码
(2)C++的内联函数具有与C中的宏定义#define相同的作用和类似机理,但消除了#define的不安全性。
(3)内联函数体内一般不能有循环语句和开关语句。
(4)后面类结构中所有在类说明体内定义的函数都是内联函数。
(5)通常较短的函数才定义为内联函数。

带有缺省参数值的函数

在C++中,函数的参数可以有缺省值。当调用有缺省参数的函数时,如果相应的参数没有给出实参,则自动用相应的缺省参数作为其实参。函数的缺省参数,是在函数原型中给定的。
说明
(1)在函数原型中,所有取缺省值的参数必须出现在不取缺省值的参数的右边。
(2)在函数调用时,若某个参数省略,则其后的参数皆应省略而采用缺省值。

函数重载

函数重载是指一个函数可以和同一作用域(命名空间)中的其他函数具有相同的名字,但这些同名函数的参数类型参数个数不同。
为什么要使用函数重载?
对于具有同一功能的函数,如果只是由于参数类型不一样,则可以定义相同名称的函数。

调用步骤:
(1)寻找一个严格的匹配,即:调用与实参的数据类型、个数完全相同的那个函数。
(2)通过内部转换寻求一个匹配,即:通过(1)的方法没有找到相匹配的函数时,则由C++系统对实参的数据类型进行内部转换,转换完毕后,如果有匹配的函数存在,则执行该函数。
(3)通过用户定义的转换寻求一个匹配,若能查出有唯一的一组转换,就调用那个函数。即:在函数调用处由程序员对实参进行强制类型转换,以此作为查找相匹配的函数的依据。

注意事项:
重载函数不能只是函数的返回值不同,应至少在形参的个数、参数类型或参数顺序上有所不同。
应使所有的重载函数的功能相同。如果让重载函数完成不同的功能,会破坏程序的可读性。

函数模板
函数模板:建立一个通用函数,其函数类型和形参类型不具体指定,而是一个虚拟类型。
应用情况:凡是函数体相同的函数都可以用这个模板来代替,不必定义多个函数,只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型,从而实现了不同函数的功能。
template<typename T>通用函数定义template<class T>通用函数定义(class和typename可以通用)

1
2
3
4
5
6
template<typename T>
T max(T a, T b)
{
if (b > a) return b;
else return a;
}

与重载函数比较:用函数模板比函数重载更方便,程序更简洁。但应注意它只适用于:函数参数个数相同而类型不同,且函数体相同的情况。如果参数的个数不同,则不能用函数模板。

作用域标识符::

通常情况下,如果有两个同名变量,一个是全局的,另一个是局部的,那么局部变量在其作用域内具有较高的优先权。
在全局变量加上::,此时::var代表全局变量。

无名联合

无名联合是C++中的一种特殊联合,可以声明一组无标记名共享同一段内存地址的数据项。如: union {int i; float j;}
在此无名联合中,声明了变量i和f具有相同的存储地址。无名联合可通过使用其中数据项名字直接存取,例如可以直接使用上面的变量i或f。

强制类型转换

C中数据类型转换的一般形式 (数据类型标识符) 表达式
C++支持这样的格式,还提供了一种更为方便的函数调用方法,即将类型名作为函数名使用,是的类型转换的执行看起来好像调用了一个函数。形式为:数据类型标识符 (表达式)。

动态内存分配

作为对C语言中malloc和free的替换,C++引进了new和delete操作符。它们的功能是实现内存的动态分配和释放
指针变量=new 数据类型;

指针变量=new 数据类型(初始值);

例如:
int *a, *b;
a = new int;
b = new int(10);

释放由new操作动态分配的内存时,用delete操作。
delete 指针变量;
例如delete a;delete b;

优点:
(1)new和delete操作自动计算需要分配和释放类型的长度。这不但省去了用sizeof计算长度的步骤,更主要的是避免了内存分配和释放时因长度出错带来的严重后果。
(2)new操作自动返回需分配类型的指针,无需使用强制类型转换
(3)new操作能初始化所分配的类型变量。
(4)new和delete都可以被重载,允许建立自定义的内存管理法。

说明:
(1)用new分配的空间,使用结束后应该用delete显示的释放,否则这部分空间将不能回收而变成死空间。
(2)使用new动态分配内存时,如果没有足够的内存满足分配要求,new将返回空指针(NULL)。因此通常要对内存的动态分配是否成功进行检查。
(3)使用new可以为数组动态分配内存空间。这时需要在类型后面加上数组大小。
指针变量 = new 类型名[下标表达式];
使用new为多维数组分配空间时,必须提供所有维的大小。
(4)释放动态分配的数组存储区时,可使用delete运算符

引用

引用就是某一变量(目标)的一个别名,这样对引用的操作就是对目标的操作。
引用的声明方法:类型标识符 &引用名=目标变量名;
说明:
(1)&在此不是求地址运算,而是起标识作用。
(2)类型标识符是指目标变量的类型。
(3)声明引用时,必须同时对其进行初始化
(4)引用声明完毕后,相当于目标变量名有两个名称。
(5)声明一个引用,不是新定义了一个变量,系统并不给引用分配存储单元。

引用的使用
(1)引用名可以是任何合法的变量名。除了用作函数的参数或返回类型外,在声明时,必须立即对它进行初始化,不能声明完后再赋值。
(2)引用不能重新赋值,不能再把该引用名作为其他变量名的别名,任何对该引用的赋值就是该引用对应的目标变量名的赋值。对引用求地址,就是对目标变量求地址。
(3)由于指针变量也是变量,所以,可以声明一个指针变量的引用。方法是类型标识符 *&引用名=指针变量名
(4)引用是对某一变量或目标对象的引用,它本身不是一种数据类型,因此引用本身不占存储单元,这样,就不能声明引用的引用,也不能定义引用的指针。
(5)不能建立数组的引用,因为数组是一个由若干个元素所组成的集合,所以就无法建立一个数组的别名。
(6)不能建立空指针的引用。
(7)不能建立空类型void的引用。
(8)尽管引用运算符与地址操作符使用相同的符号,但是不一样的。引用仅在声明时带有引用运算符&,以后就像普通变量一样使用,不能再带&。其他场合使用的&都是地址操作符。

用引用作为函数的参数
一个函数的参数可以定义成引用的形式。
在主调函数的调用点处,直接以变量作为实参进行调用即可,不需要实参变量有任何的特殊要求。

用引用返回函数值
函数可以返回一个引用,将函数说明为返回一个引用。
主要目的是:为了将函数用在赋值运算符的左边。要以引用返回函数值。
类型标识符 &函数名 (形参列表及类型说明){函数体}
(1)以引用返回函数值,定义函数时需要在函数名前加&
(2)用引用返回一个函数值的最大好处是,在内存中不产生返回值的副本。
在定义返回引用的函数时,注意不要返回该函数内的自动变量(局部变量)的引用,由于自动变量的生存期仅限于函数内部,当函数返回时,自动变量就消失了。

一个返回引用的函数值作为赋值表达式的左值
一般情况下,赋值表达式的左边只能是变量名,即被赋值的对象必须是变量,只有变量才能被赋值。

Lecture 2

类的构成
数据成员、成员函数

private, protected, public

· private 部分称为类的私有部分,这一部分的数据成员和成员函数称为类的私有成员。私有成员只能由本类的成员函数访问,而类外部的任何访问都是非法的。(只能在定义、实现的时候访问)
· public 部分称为类的共有部分,这部分的数据成员和成员函数称为类的公有成员。公有成员可以由程序中的函数访问,它对外是完全开放的。
· protected 部分称为类的保护部分,这部分的数据成员和成员函数称为类的保护成员。保护成员可以由本类的成员函数访问,也可以由本类的派生类的成员函数访问,而类外的任何访问都是非法的。

(1)类声明格式中的3个部分并非一定要全有,但至少要有其中的一个部分。
一般一个类的数据成员应该声明为私有成员,成员函数声明为公有成员。
(2)类声明中的private, protected, public三个关键字可以按任意顺序出现任意次。但是,如果把所有的私有成员、保护成员和公有成员归类放在一起,程序将更加清晰。
(3)private处于类体重第一部分时,关键字private可以省略。
(4)数据成员可以是任何数据类型,但不能用自动(auto)、寄存器(register)或外部(extern)进行声明。
(5)不能在类声明中给数据成员赋值。C++规定,只有在类对象定义之后才能给数据成员赋初值。

类成员的访问属性
类的成员对类对象的可见性和对类的成员函数的可见性是不同的。
类的成员函数可以访问类的所有成员,而类的对象对类的成员的访问是受类成员的访问属性的制约的。

一般来说,公有成员是类的对外接口,而私有成员和保护成员是类的内部数据和内部实现,不希望外界访问。将类的成员划分为不同的访问级别有两个好处:一是信息隐蔽,即实现封装;二是数据保护,即将类的重要信息保护起来,以免其他程序不恰当地修改。

对象赋值语句
两个同类型的变量之间可以相互赋值。同类型的对象间也可以进行赋值,当一个对象赋值给另一个对象时,所有的数据成员都会逐位拷贝。
说明:
·在使用对象赋值语句进行对象赋值时,两个对象的类型必须相同,如果对象的类型不同,编译时将出错。
·两个对象之间的赋值,仅仅使这些对象中数据成员相同,而两个对象仍是分离的。
·=的对象赋值是通过缺省的赋值运算符函数实现的。(复杂的需要重载)
·当类中存在指针时,使用缺省的赋值运算符进行对象赋值,可能会产生错误。

Lecture 3

构造函数与析构函数

构造函数和析构函数都是类的成员函数,但它们都是特殊的成员函数,执行特殊的功能,不用调用便自动执行,而且这些函数的名字与类的名字有关。
C++语言中有一些成员函数性质是特殊的,这些成员函数负责对象的建立、删除。这些函数的特殊性在于可以由编译器自动地隐含调用,其中一些函数调用格式采用运算符函数重载的语法。C++引进一个自动完成对象初始化过程的机制,这就是类的构造函数。

对象的初始化
1)数据成员是不能在声明类时初始化
2)类型对象的初始化方法:
·调用对外接口(public成员函数)实现 声明类→定义对象→调用接口给成员赋值
·应用构造函数(constructor)实现 声明类→定义对象→同时给成员赋值

构造函数
构造函数是一种特殊的成员函数,它主要用于为对象分配空间,进行初始化。构造函数具有一些特殊的性质:
(1)构造函数的名字必须与类名相同。
(2)构造函数可以有任意类型的参数,但不能指定返回类型。它有隐含的返回值,该值由系统内部使用。
(3)构造函数是特殊的成员函数,函数体可写在类体内,也可写在类体外。
(4)构造函数可以重载,即一个类中可以定义多个参数个数或参数类型不同的构造函数。构造函数是不能继承。
(5)构造函数被声明为公有函数,但它不能像其他成员函数那样被显式地调用,它是在定义对象的同时调用的
·在声明类时如果没有定义类的构造函数,编译系统就会在编译时自动生成一个默认形式的构造函数。
·默认构造函数是构造对象时不提供参数的构造函数。
·除了无参数构造函数是默认构造函数外,带有全部默认参数值的构造函数也是默认构造函数。
·自动调用:构造函数在定义类对象时自动调用,不需用户调用,也不能被用户调用。在对象使用前调用。
·调用顺序:在对象进入其作用域时(对象使用前)调用构造函数。

利用构造函数创建对象的两种方法:
(1)利用构造函数直接创建对象,其一般形式为:类名 对象名[(实参表)];
这里的“类名”与构造函数名相同,“实参表”是为构造函数提供的实际参数。
(2)利用构造函数创建对象时,通过指针和new来实现。其一般语法形式为:类名 *指针变量 = new 类名 [(实参表)];

例2.19 用p2 = p1试一下0.0

析构函数
析构函数也是一种特殊的成员函数。它执行与构造函数相反的操作,通常用于撤销对象时的一些清理任务,如释放分配给对象的内存空间等。
析构函数有以下一些特点:
①析构函数与构造函数名字相同,但它前面必须加一个波浪号(~);
②析构函数没有参数,也没有返回值,而且不能重载。因此在一个类中只能有一个析构函数;
③当撤销对象时,编译系统会自动调用析构函数。如果程序员没有定义析构函数,系统将自动生成和调用一个默认析构函数,默认析构函数只能释放对象的数据成员所占用的空间,但不包括堆内存空间。

Lecture 7-8

继承与派生类

继承目的:代码的重用和代码的扩充
继承方法程序设计思路:一般->特殊
继承种类:单继承、多继承
继承方式:public protected private
继承内容:除构造函数、析构函数、私有成员外的其他成员

保持已有类的特性而构造新类的过程称为继承
在已有类的基础上新增自己的特性而产生新类的过程称为派生
被继承的已有类称为基类(父类)。
派生出的新类称为派生类。

类库 STL

类库是面向对象的软件开发环境的核心。

类库是类的集合,并且给出了多种类之间的关系描述。