c期末复习资料.doc

1、 面向对象相关概念：
类：具有相同属性和行为的对象集合，把数据和操作封装在一起
对象：数据+操作。
面向对象特征：抽象，封装，继承，多态
2、输入输出：输入cin>>a>>b;输入不能有endl。 输出cout<<a<<b<<endl;
3、const修饰符：
l 指向常量的指针：如const char *p=”abcd”;不允许改变指针所指的常量，如p[3]=’x’是错误的，但是可以改变指针p的值p=“mn”；是对的。
l 常指针：char *const p =“abcd”；指针本身是常量，不能移动，但是所指内容为变量，可以更改，如p[3]=’x’是对的。
l 常数据成员，常成员函数，常对象：在类中声明的数据或函数可以是常量，对于常数据成员要用初始化列表初始值，在C++类中，const关键字可以修饰对象和成员函数，const对象不能被修改，一个常对象只能调用它的常成员函数，不能调用普通成员函数。
常成员函数格式：类型说明符 函数名（参数表）const；常成员函数可以参加重载。常成员函数不能更新对象的数据成员，也不能调用该类中的普通成员函数，const成员函数不能修改数据成员。
4、内联函数：在函数说明前冠以关键字inline，目的是消除函数调用时的系统开销，提高运行速度。
注意：
内联函数体内不能有循环语句和switch语句。
内联函数的声明必须出现在内联函数第一次被调用之前。
类结构中所有在类说明体内定义的函数都是内联函数。
5、带有缺省参数值的函数：在说明函数原型时，可以给一个或多个形参指定缺省值，调用时如给出实参，则采用实参值，否则采用预先给出的默认形参值。如某一个类point的构造函数原型为point(int x=1, int y=0);则参数x和y的缺省值为1和0.
注意：
在函数原型中，所有缺省值的参数都必须从右往左缺省，在函数调用时从左往右将实参与形参结合,如point(int x=1, int y=0) {X=x；Y=y；},那么执行point p(3)之后p的X和Y值分别为3，0.
6、函数重载：C++允许功能相近的函数在相同的作用域内以相同函数名声明，从而形成重载。
注意：
重载函数的形参必须不同: 个数不同或类型不同。编译程序将根据实参和形参的类型及个数的最佳匹配来选择调用哪一个函数。
例：
void add(int m, int n)
{ cout<<”two integer numbers m+n=”<<m+n<<endl; }
void add(float x,float y)
{ cout<<”two float numbers m+n=”<< m+n<<endl; }
int i=1,j=2;float f=1.0,d=2.0;
add(i,j);add(f,d);则前者调用第一个函数，后者调用第二个函数
输出two integer numbers m+n=3
two float numbers m+n=3.0
7、引用：引用(&)是标识符的别名，例如:int i;int &ri=i; //建立一个int型的引用ri,并将其初始化为变量i的一个别名。
注意：
声明一个引用时，必须同时对它进行初始化，使它指向一个已存在的对象，不能声明完成后再赋值，如 int i;
int &ri;//错误
ri=i;
一旦一个引用被初始化后，就不能改为指向其它对象。如：int i,j;
int &ri=i;
ri=&j;//错误
引用可以作为形参作为传地址调用，效果和指针一样。void swap(int& a, int& b) {...}
引用与地址符的区别：引用运算符仅在声明是带有引用运算符&，以后就像使用普通变量一样，其他场合使用&都是地址操作符
8、作用域标识符（::）如果希望在局部变量的作用域内使用同名的全局变量，在该变量前加上::，如::a代表全局变量。
9、new和delete
运算符new用来内存分配，最基本格式为：指针变量=new 类型名；该语句在程序运行时从自由存储区中为程序分配一类型名字节大小空间，该空间首地址被存于指针变量中。
运算符delete用于释放new分配的存储空间，基本格式：delete 指针名；
说明：
l 可以用new将分配的对象初始化，new和delete都可以重载。
l new分配的空间使用结束后应该也只能用delete显式释放，否则将不能回收而变成死空间
l 使用new为数组动态分配内存：指针变量=new 类型名[下标值];如int *p=new int[10];
释放时：delete []指针变量名；如delete []p;
l new可以为简单变量分配内存时同时进行初始化，指针变量=new 类型名（初始化列表）；
如int *p=new int(10);
10、类是一种用户自定义类型，声明形式：
class 类名称
{
public:
公有成员（外部接口）
private:
私有成员
protected:
保护型成员
}；类成员中缺省访问方式为私有
l 公有类型成员：在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数。
l 私有类型成员：在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。如果紧跟在类名称的后面声明私有成员，则关键字private可以省略。
l 保护类型：在类的定义中，说明为protected的数据成员称为保护成员。保护数据成员具有双重作用：对于其派生类而言，是公有的，而对于其外部的程序而言，是私有的
l 类的成员：成员数据与一般的变量声明相同，但需要将它放在类的声明体中。成员函数在类中说明原形，可以在类外给出函数体实现，并在函数名前使用类名加以限定。也可以直接在类中给出函数体，形成内联成员函数。
l 类的对象是该类的某一特定实体，即类类型的变量。声明形式：
类名 对象名； 例：Clock myClock;
l 类中成员的访问方式：类中成员互访：直接使用成员名 类外访问：使用“对象名.成员名”或“对象指针名->成员名“方式访问 public 属性的成员
11、构造函数
构造函数的作用是在对象被创建时使用特定的值构造对象，或者说将对象初始化为一个特定的状态。
特点：
l 在对象创建时或new类名时由系统自动调用。
l 如果程序中未声明，则系统自动产生出一个默认形式的构造函数，只有程序中定义有构造函数，系统不再自动生成缺省的构造函数
缺省构造函数 类名：：缺省构造函数名（）{}
l 函数名必须与类名相同
l 不能指定函数返回类型
l 参数可以有，也可以无，参数可以带默认形参值，所以一个类可以有多个构造函数，从而构造函数可以重载。如有一个类A，当执行语句A a；时将自动调用该类的无参构造函数或缺省的构造函数或带默认形参值的构造函数，但无参构造函数和带默认形参值的构造函数二者同时出现容易出现调用时引起二义性
l 允许是内联函数
利用构造函数创建对象有两种方法：
l 用构造函数之间创建对象：类名 对象名(实参表)；如point p（1，2）；
l 利用构造函数创建对象时，通过指针和new来实现：
类名 *指针变量=new 类名(实参表)；
如A *p=new A(1，2)；注意类A声明对象指针并不调用构造函数，而是通过new创建临时对象调用构造函数，所以该语句只调用构造函数1次
12、拷贝构造函数
拷贝构造函数是一种特殊的构造函数，其形参为本类的对象引用，作用是用已经存在的对象初始化另一个同类的新对象。
类名（类名 &对象名）；//拷贝构造函数 如类A拷贝构造函数为： A (A &x)；
拷贝构造函数特点：
l 也是构造函数，所以其函数名与类名相同，没有返回值
l 只有一个参数，并且是本类的对象引用，所以一个类只能有一个，不能重载
l 每一个类都有一个拷贝构造函数，如果没有定义，系统会自动生成一个缺省的
调用拷贝构造函数3种情况：
l 当用类的一个对象去初始化该类的另一个对象时系统自动调用拷贝构造函数实现拷贝赋值。
l 若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数。
l 当函数的返回值是类对象时，系统自动调用拷贝构造函数。
深拷贝和浅拷贝：缺省的拷贝构造函数所实现的数据成员逐一赋值就是浅拷贝，当类中有指针时，需要自定义拷贝构造函数，谓深拷贝。
13、析构函数
完成对象被删除前的一些清理工作。
特点：
l 析构函数与构造函数名相同，但它前面必须加一个波浪号~
l 析构函数没有返回值
l 析构函数没有参数，所以一个类中只能有一个析构函数，所以析构函数不能重载
l 当撤销对象时，或delete对象指针编译系统自动调用析构函数
l 如果没有定义析构函数，系统自动生成一个缺省的析构函数
类名：：~缺省析构函数名（）{}
14、成员初始化列表
在声明类时，不能在数据成员的声明中对数据成员进行初始化，一般在构造函数中用赋值语句进行，但对于内嵌的对象、常量、引用数据成员需要在构造函数的成员初始化列表中进行。带有成员初始化列表的构造函数一般格式：
类名：：构造函数名（参数表）：（成员初始化列表）{。。。。}
15、this指针隐含于每一个类的成员函数中的特殊指针。
16、对象数组：类名 数组名[下标值]；该数组中每个元素都是对象，都会自动调用构造函数，当数组中每一个对象被删除时，系统都要调用一次析构函数。
访问方法：数组名[下标].成员名
17、对象指针：类名 *对象指针名；定义对象指针不会调用构造函数
利用对象指针可以访问单个对象成员，如point *p，ob；p=&ob；p->show();或(*p).show();
也可以用对象指针访问对象数组，对象可以作为函数参数，对象指针也可以
18、指向类成员的指针：通过指向成员的指针只能访问公有成员
指向类的非静态成员的指针
l 指向公有数据成员的指针：类型说明符 类名：：*数据成员指针名；说明指针应该指向哪个成员：指针名=&类名::数据成员名；通过对象名（或对象指针）与成员指针结合来访问数据成员： 对象名.* 类成员指针名 或： 对象指针名->*类成员指针名
l 声明指向公有函数成员的指针：类型说明符 (类名::*指针名)(参数表)；初始化：指针名=类名::函数成员名；通过对象名（或对象指针）与成员指针结合来访问函数成员：
(对象名.* 类成员指针名)(参数表)或：(对象指针名->*类成员指针名)(参数表)
指向类的静态成员的指针
l 对类的静态成员的访问不依赖于对象，可以用普通的指针来指向和访问静态成员
19、静态成员
l 静态数据成员
l 用关键字static声明，该类的所有对象维护该成员的同一个拷贝，必须在类外定义和初始化，用(::)来指明所属的类。初始化格式：数据类型 类名：：静态数据成员名=值；静态数据属于整个类，因此既可以通过某个对象，或对象指针去访问，也可以使用类名：：静态数据成员名格式去访问它。
l 静态成员函数
n 一般来说，静态成员函数只能引用属于该类的静态数据成员或静态成员函数。
n 静态成员函数没有this指针
n 类外代码可以使用类名和作用域操作符来调用静态成员函数。如类名：：静态成员函数名（实参表）或者对象。静态成员函数名（实参表）或对象指针-〉静态成员函数名（实参表）
如某类A：
class A
{
private:
   static int totalW；
   int w；
public:
  A (int m)
{
      w = m；
      totalW +=m；
 }
~A (){totalW - =w ；}
   static int getT () { return totalW ；}
}；
int A:: totalW =0；
void main ()
{
A al (50)；
   cout <<A:: getT () <<endl；
   A a2 (100)；
   cout << a2.getT () << endl；
}
20、友元
友元是C++提供的一种破坏数据封装和数据隐藏的机制。提高程序运行效率
l 友元函数
不是当前类的成员函数，而是对立于当前类的外部函数，它可以访问该类的所有成员，包括公有，私有，受保护。友元函数不是类的成员，所以没有this指针，它不能直接引用对象成员的名字，它必须通过入口参数传递进来的对象名或对象指针来引用该对象的成员。如某类girl的友元函数disp格式：void disp(girl &g);
l 友元成员
一个类的成员函数作为另一个类的友元，它既可以访问本类的所有成员，还可以访问friend声明所在类的所有成员
l 友元类
若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。
l 友元关系是单向的，不具有交换性和传递性
21、派生类
l 继承的目的：实现代码重用。派生的目的：当新的问题出现，原有程序无法解决（或不能完全解决）时，需要对原有程序进行改造。
l 派生类的声明
class 派生类名：继承方式 基类名
{
成员声明；
}；
继承方式：三种继承方式(省略默认为私有继承)，公有继承，私有继承，保护继承
不同继承方式的影响主要体现在：
内部访问：派生类成员对基类成员的访问权限
对象访问：通过派生类对象对基类成员的访问权限
在派生类中能够直接访问的是基类的公有成员和保护成员
l 公有继承(public)
基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可直接访问。
派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。
通过派生类的对象只能访问基类的public成员。
l 私有继承(private)
基类的public和protected成员都以private身份出现在派生类中，但基类的private成员不可直接访问。
派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。
通过派生类的对象不能直接访问基类中的任何成员。
l 保护继承(protected)
基类的public和protected成员都以protected身份出现在派生类中，但基类的private成员不可直接访问。
派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。
通过派生类的对象不能直接访问基类中的任何成员
22、类型兼容规则
l 一个公有派生类的对象在使用上可以被当作基类的对象，反之则禁止。具体表现在：
– 派生类的对象可以被赋值给基类对象。
– 派生类的对象可以初始化基类的引用。
– 指向基类的指针也可以指向派生类。
l 通过基类对象名、指针只能使用从基类继承的成员
23、多继承时派生类的声明
class 派生类名：继承方式1 基类名1，继承方式2 基类名2，...
{
成员声明；
}
注意：每一个 “继承方式 ”，只用于限制对紧随其后之基类的继承。
24、继承时的构造函数
l 基类的构造函数不被继承，派生类中需要声明自己的构造函数。
l 声明构造函数时，只需要对本类中新增成员进行初始化，对继承来的基类成员的初始化，自动调用基类构造函数完成。
l 派生类的构造函数需要给基类的构造函数传递参数，要看具体情况
在类继承过程中，当基类只有带默认值的有参构造函数时，派生类的构造函数可能为：默认构造函数，不带参数构造函数，带参数构造函数；当基类只有不带默认值的有参构造函数时，派生类必须有构造函数
l 单一继承时的构造函数
派生类名::派生类名(基类所需的形参，本类成员所需的形参):基类名(参数表)
{
本类成员初始化赋值语句；
}；
l 多继承且有内嵌对象时的构造函数
派生类名::派生类名(基类1形参，基类2形参，...基类n形参，本类形参):基类名1(参数), 基类名2(参数), ...基类名n(参数)，内嵌对象数据成员的初始化
{
本类成员初始化赋值语句；
}；
构造函数的调用次序
1． 调用基类构造函数，调用顺序按照它们被继承时声明的顺序（从左向右）。
2． 调用内嵌成员对象的构造函数，调用顺序按照它们在类中声明的顺序。
3． 派生类的构造函数体中的内容。
25、继承时的析构函数
l 析构函数也不被继承，派生类自行声明
l 声明方法与一般（无继承关系时）类的析构函数相同。
l 不需要显式地调用基类的析构函数，系统会自动隐式调用。
l 析构函数的调用次序与构造函数相反。
26、虚基类
l 用于有共同基类的场合
l 以virtual修饰说明基类
例：class B1:virtual public B
27、多态
l 多态的分类：参数多态，包含多态，重载多态和强制多态
l 多态的实现：函数模板和类模板，虚函数，函数重载、运算符重载
l 虚函数
² 虚函数是动态绑定的基础，实现多态的重要手段。
² 定义在基类中进行，在类的声明中，在函数原型之前写virtual。
² virtual 只用来说明类声明中的原型，不能用在函数实现时。
² 具有继承性，基类中声明了虚函数，派生类中无论是否说明，同原型函数都自动为虚函数。
² 在派生类中重新定义时，其函数原型都必须和基类中的原型完全相同。
² 调用方式：通过基类指针或引用，执行时会根据指针指向的对象的类，决定调用哪个函数。
² 不能是友元函数，不能是静态成员函数；不能是内联函数；不能是构造函数；可以是析构函数。
² 要求会分析具有虚函数的程序运行结果
l 纯虚函数
² 是在基类中说明的虚函数，它在该基类中没有定义，但要求在它的派生类中必须定义自己的版本，或重新说明为纯虚函数:
² virtual 函数类型 函数名(参数表)=0;
² 声明为纯虚函数后在基类中就不再给出函数实现部分，函数体有派生类给出。
² 带有纯虚函数的类称为抽象类:
² 不能声明抽象类的对象，可以声明指向抽象类的指针或引用。
² 如果派生类中没有实现纯虚函数，只是继承基类的纯虚函数，该派生类还是一个抽象类
l 运算符重载
规则和限制
Ø 可以重载C++中除下列运算符外的所有运算符：
. .* :: ?:
Ø 只能重载C++语言中已有的运算符，不可臆造新的。
Ø 不改变原运算符的优先级和结合性。
Ø 不能改变操作数个数。
Ø 经重载的运算符，其操作数中至少应该有一个是自定义类型。
两种形式
Ø 重载为类成员函数。
Ø 重载为友元函数。
Ø 运算符函数
声明形式
函数类型 operator 运算符（形参）
{
......
}
重载为类成员函数时 ：参数个数=原操作数个数-1 （后置++、--除外）如类中重载二元运算符为成员运算符时，只能指定1个参数。
重载为友元函数时：参数个数=原操作数个数，且至少应该有一个自定义类型的形参。如类中重载二元运算符为友元函数时，指定2个参数。
例 ： 将“+”、“-”运算重载为复数类的成员函数。
例 ： 将“+”、“-”运算重载为复数类的友元函数。
Ø 规则:实部和虚部分别相加减。
Ø 操作数:两个操作数都是复数类的对象。
Ø 具体程序参考幻灯片或者作业8
28、模板
模板是实现代码重用机制的一种工具,它可以实现类型参数化,即把类型定义为参数,从而实现了真正的代码重用。模板分为函数模板和类模板,它们分别允许用户构造模板函数和模板类。
Ø 函数模板的一般说明形式如下:
template <class/typename 类型参数> 注意class小写
返回类型 函数名(模板形参表)
{
函数体
}
在函数模板中允许使用多个类型参数。template<typename t1,typename t2>
Ø 类模板：
template <class 模板参数表>class 类名
{类成员声明}；
如果需要在类模板以外定义其成员函数，则要采用以下的形式：
template <模板参数表>类型名 类名<T>::函数名（参数表）