派生类简介_派生类个人资料_派生类微博_百科网
A-A+

派生类简介_派生类个人资料_派生类微博

2017-09-24 01:20:03 科学百科 阅读 10 次

单一继承/派生类 编辑

在“单一继承”这种最普通的形式中,派生类仅有一个基类。

在类的层次设计中,可以发现一些普遍的特性,即派生类总是同基类有“kind of”关系。

另一个值得注意点是Book既是派生类(从PrintedDocument中派生),也是基类(PaperbackBook是从Book派生的)。下面的例子是这种类层次的一个轮廓性的说明。

class PrintedDocument

{

//成员表

};

//Book是从PrintedDocument中派生的

class Book:public PrintedDocument

{

//成员表

};

//PaperbackBook是从Book中派生

class PaperbackBook: public Book

{

//成员表

};

PrintedDocument作为Book的直接基类,它同时也是PaperbackBook的非直接 基类。直接基类和非直接基类的区别在于直接基类出现在类说明的基类表中,而非直接基类不出现在基类表中。

每个派生类的说明是在基类的说明之后说明的,因此对于基类仅只给出一个前向引用的说明是不够的,必须是完全的说明。

一个类可以作为很多特别类的基类。

在继承中,派生类含有基类的成员加上任何你新增的成员。结果派生类可以引用基类的成员(除非这些成员在派生类中重定义了)。当在派生类中重定义直接基类或间接基类的成员时,可以使用范围分辨符(::)引用这些成员。考虑下面的代码:

class Document

{

public:

char * Name;//文档名称

void PrintNameOf(); //打印名称

};

//实现类Document的PrintNameOf函数

void Document::PrintNameOf()

{

cout << Name << end ;

}

class Book:public Document

{

public:

Book(char *name,long pagecount);

private:

long PageCount;

};

//class Book 构造函数

Book::Book (char *name,long pagecount)

{

Name=mew char [strlen(name)+1];

strcpy (Name,name);

PageCount=pagecount;

};

注意,Book的构造函数(Book::Book)具有对数据成员Name的访问权。在程序中可以按如下方式创建Book类对象并使用之。

//创建一个Book类的新对象,这将激活构造函数Book:BookBook

LibraryBook ("Programming Windows,2nd Ed",994);

...

//使用从Document中继承的函数PrintNameOf.

LibraryBook.PrintNameOf();如前面例子所示,类成员和继承的数据与函数以一致的方式引用。如果类Book所调用的PrintNameOf是由类Book重新定义实现的,则原来属于类Document的PrintNameOf函数只能用范围分辩符(::)才能使用:

class Book:public Document

{

Book(char *name,long pagecount);

void PrintNameOf();

long PageCount;

};

void Book::PrintNameOf()

{

cout<<"Name of Book:";

Document::PrintNameOf();

}

只要有一个可访问的、无二义性的基类,派生类的指针和引用可以隐含地转换为它们基类的指针和引用。下面的例子证实了这种使用指针的概念(同样也适用于引用):

#include < iostream.h>

void main()

{

Document * DocLib; //10个文档的库

for (int i=0; i<10; ++i)

{

cout<<"Type of document:"

<<"P)aperback,M)agazine,H)elp File,C)BT"

<< endl;

char CDocType;

cin >>CDocType;

switch(tolower(CDocType))

{

case 'p':

DocLib=new PaperbackBook;

break;

case 'm':

DocLib=new Magazine;

break;

case 'h':

DocLib=new HelpFile;

break;

case 'c':

DocLib=new ComputerBasedTraining;

break;

default:

--i;

break;

}

}

for (i=0; i<10; ++i)

DocLib->PrintNameOf();

}

在前面例子的SWITCH语句中,创建了不同类型的对象。这一点依赖于用户对CDocType对象所作出的说明。然而这些类型都是从类Document中派生出来的,故可以隐含地转换为Document*。结果是DocLib成为一个“相似链表”(heterogeneous list)。此链表所包含的是不同种类的对象,其中的所有对象并不是有相同的类型。

因为Document类有一个PrintNameOf函数。因此它能够打印图书馆中每本书的名称,但对于Document类型来说有一些信息会省略掉了(如:Book的总页数,HelpFile的字节数等)。

注意:强制基类去实现一个如PrintNameOf的函数,通常不是一个很好的设计,本章后面的“ 虚拟函数”中提供了一个可替换的设计方法。

二义性/派生类 编辑

实例

多重继承使得从不同的路径继承成员名称成为可能。沿着这些路径的成员名称并不必然是唯一的。这些名称的冲突称为“二义性”。

任何引用类成员的表达式必须使用一个无二义性的引用。下面的例子显示了二义性是如何发生的。//说明两个基类A和B

class A

{

public:

unsigned a;

unsigned b();

};

class B

{

public:

unsigned a(); //注意类A也有一个成员"a"和一个成员"b"

int b();

char c;

};

//定义从类A和类B中派生出的类C

class C : public A,public B

{

};

分析

按上面所给出的类说明,如下的代码就会引出二义性,因为不清楚是引用类A的b呢,还是引用类B的b:

C *pc=new C;

pc->b();

考虑一下上面的代码,因为名称a既是类A又是类B的成员,因而编译器并不能区分到底调用哪一个a所指明的函数。访问一个成员,如果它能代表多个函数、对象、类型或枚举则会引起二义性。

编译器通过下面的顺序执行以检测出二义性:

⒈ 如果访问的名称是有二义性的(如前述),则产生一条错误信息。

⒉ 如果重载函数是无二义性的,它们就没有什么问题了

⒊ 如果访问的名称破坏了成员访问许可,则产生一条错误信息

在一个表达式产生了一个通过继承产生的二义性时,通过用类名称限制发生问题的名称即可人工解决二义性,要使前面的代码以无二义性地正确编译,要按如下使用代码:

C *pc = new C;

pc->B::a();

注意:在类C说明之后,在C的范围中引用B就会潜在地引起错误。但是,直到在C的范围中实际使用了一个对B的无限定性的引用,才会产生错误。

二义性和虚拟基类

如果使用了虚拟基类、函数、对象、类型以及枚举可以通过多重继承的路径到达,但因为只有一个虚拟基类的实例,因而访问这些名称时,不会引起二义性。

访问任何类A的成员,通过非虚拟基类访问则会引起二义性;因为编译器没有任何信息以解释是使用同类B联系在一起的子对象,还是使用同类C联系在一起的子对象,然而当A说明为虚拟基类时,则对于访问哪一个子对象不存在问题了。

通过继承图可能有多个名称(函数的、对象的、枚举的)可以达到。这种情况视为非虚拟基类引起的二义性。但虚拟基类也可以引起二义性,除非一个名称“支配”(dominate)了其它的名称。一个名称支配其它的名称发生在该名称定义在两个类中,其中一个是由另一个派生的,占支配地位的名称是派生类中的名称,在此名称被使用的时候,相反不会产生二义性,如下面的代码所示:

class A

{

public:

int a;

};

class B: public virtual A

{

public:

int a();

};

class C: public virtual A

{

...

};

class D: public B,public C

{

public:

D() {a();} //不会产生二义性,B::a()支配了A::a

};

转换的二义性

显式地或隐含地对指向类类型的指针或引用的转换也可引起二义性。

实例1

虚拟函数可以确保在一个对象中调用正确的函数,而不管用于调用函数的表达式。

假设一个基类含有一个说明为虚拟函数同时一个派生类定义了同名的函数。派生类中的函数是由派生类中的对象调用的,甚至它可以用指向基类的指针和引用来调用。下面的例子显示了一个基类提供了一个PrintBalance函数的实现:

class Account

{

public:

Account(double d); //构造函数

virtual double GetBalance(); //获得平衡

virtual void PrintBalance(); //缺省实现

private:

double _balance;

};

//构造函数Account的实现

double Account::Account(double d)

{

_balance=d;

}

//Account的GetBalance的实现

double Account::GetBalance()

{

return _balance;

}

//PrintBalance的缺省实现

void Account::PrintBalance()

{

cerr<<"Error.Balance not available for base type".

<

}

两个派生类CheckingAccount和SavingsAccount按如下方式创建:

class CheckingAccount:public Account

{

public:void

PrintBalance();

};

//CheckingAccount的PrintBalance的实0现

void CheckingAccount::PrintBalance()

{

cout<<"Checking account balance:"

<< GetBalance();

}

class SavingsAccount:public Account

{

public:

void PrintBalance();

};

//SavingsAccount中的PrintBalance的实

现void SavingsAccout::PrintBalance()

{

cout<<"Savings account balance:"

<< GetBalance();

}

函数PrintBalance在派生类中是虚拟的,因为在基类Account中它是说明为虚拟的,要调用如PrintBalance的虚拟函数,可以使用如下的代码:

//创建类型CheckingAccount和SavingsAccount的对象

SavingsAccount *pSavings=new SavingsAccount(1000.00);

//用指向Account的指针调用PrintBalance

Account *pAccount=pChecking;

pAccount->PrintBalance();

//使用指向Account的指针调用PrintBalance

pAccount=pSavings;

pAccount->PrintBalance();

分析1

在前面的代码中,除了pAccount所指的对象不同,调用PrintBalance的代码是相同的。

因为PrintBalance是虚拟的,将会调用为每个对象所定义的函数版本,在派生类CheckingAccount和SavingsAccount中的函数“复盖”了基类中的同名函数。如果一个类的说明中没有提供一个对PrintBalance的复盖的实现,则将采用基类Account中的缺省实现。

实例2

派生类中的函数重载基类中的虚拟函数,仅在它们的类型完全相同时才如此。派生类中的函数不能仅在返回值上同基类中的虚拟函数不同;参量表也必须不同。当指针或引用调用函数时,要遵循如下规则:

* 对虚拟函数调用的解释取决于调用它们的对象所基于的类型。

* 对非虚函数调用的解释取决于调用它们的指针或引用的类型。

下面例子显示了在使用指针调用虚拟或非虚拟函数时它们的行为:#include

//说明一个基类

class Base

{

public:

virtual void NameOf(); //虚拟函数

void InvokingClass(); //非虚拟函数

};

//两个函数的实现

void Base::NameOf()

{

cout<<"Base::NameOfn";

}

void Base::InvokingClass()

{

cout<<"Invoked by Basen";

}

//说明一个派生类

class Derived:public Base

{

public:

void NameOf(); //虚拟函数

void InvokingClass(); //非虚拟函数

};

//两个函数的实现

void Derived::NameOf()

{

cout<<"Derived::NameOfn";

}

void Derived::InvokingClass()

{

cout<<"Invoked by Derivedn";

}

void main()

{

//说明一个Derived类型的对象

Derived aDerived;

//说明两个指针,一个是Derived*型的,另一个是Base*型的,并用 //aDerived初始化它们。

Derived *pDerived=&aDerived;

Base *pBase =&aDerived;

//调用这个函数

pBase->NameOf(); //调用虚拟函数

pBase->InvokingClass();//调用非虚拟函数

pDerived->NameOf();//调用虚拟函数

pDerived->InvokingClass(); //调用非虚拟函数

}

分析2

该程序的输出是:

Derived::NameOf

Invoked by Base

Derived::NameOf

Invoked by Derived

注意,不管调用NameOf函数的指针是通过指向基类的指针还是指向派生类的指针,它调用的函数是派生类的。因为NameOf是虚拟函数,而且pBase和pDerived指向的对象都是派生类的,故而调用函数是派生类的。

因为虚拟函数只能为类类型的对象所调用,所以你不能把一个全局的或静态函数说明为虚拟的。

在派生类中说明一个重载函数时可以用virtual关键字,但是这并不是必须的,因为重载一个虚拟函数,此函数就必然是虚拟函数。

基类中的虚拟函数必须有定义,除非它们被说明为纯的。

虚拟函数调用机制可以用范围分辨符(::)明确地限定函数名称的方法来加以限制。考虑前面的代码,用下面的代码调用基类的PrintBalance。

pChecking->Account::PrintBalance(); //明确限定

Account *pAccount=pChecking; //调用Account::PrintBalance

pAccount->Account::PrintBalance();//明确限定

上面例子中的两个对PrintBalance的调用都限制了虚拟函数的调用机制。

抽象类/派生类 编辑

抽象类就像一个一段意义上的说明,通过它可以派生出特有的类。你不能为抽象类创建一个对象,但你可以用抽象类的指针或引用。

至少含有一个纯虚拟函数的类就是抽象类。从抽象类中派生出的类必须为纯虚拟函数提供实现,否则它们也是抽象类。

把一个虚拟函数说明为纯的,只要通过纯说明符语法,考虑一下本章早些时候在“虚拟函数”中提供的例子。类Account的意图是提供一个通常意义的函数功能,Account类型的对象太简单而没有太多用处。因此Account是作为抽象类的一个很好的候选:

实例1

class Account

{

public:

Account(double d); //构造函数

virtual double GetBalance();//获得平衡

virtual void PrintBalance()=0; //纯虚拟函数

Private:

double _balance;

};

分析1

这里的说明同前一次的说明的唯一不同是PrintBalance是用纯说明符说明的。

使用抽象类的限制

抽象类不能用于如下用途:

*变量或成员数据

* 参量类型

* 函数的返回类型

* 明确的转换类型

另外一个限制是如果一个抽象类的构造函数调用了一个纯虚拟函数,无论是直接还是间接的,结果都是不确定的。但抽象类的构造函数的析构函数可以调用其它成员函数。

抽象类的纯虚拟函数可以有定义,但它们不能用下面语法直接调用:

抽象类名称::函数名称()

实例2

在设计基类中含有纯虚拟析构函数的类层次时,这一点很有用。因为在销毁一个对象的过程中通常都要调用基类的析构函数,考虑下面的例子:#include

//说明一个带有纯虚拟析构函数的抽象类

class base

{

public:

base() { }

virtual ~base()=0;

};

//提供一个析构函数的定义

base::~base()

{

};

class derived:public base

{

public: derived(){ };

~derived() { };

};

void main()

{

derived *pDerived=new derived;

delete pDerived;

}

分析2

当一个由pDerived所指的对象销毁的时候,会调用类derived的析构函数,进而调用基类base中的析构函数。纯虚拟函数的空的实现保证了该函数至少存在着一些操作。注意:在前面例子中,纯虚拟函数base::~base是在derived::~derived中隐含调用的。当然明确地用全限定成员函数名称去调用纯虚拟函数是可能的。

-------------------------------------------------------------------------------

继承方式/派生类 编辑

public 基类的public和protected的成员被派生类继承后,保持原来的状态
private 基类的public和protected的成员被派生类继承后,变成派生类的private成员
protected 基类的public和protected的成员被派生类继承后,变成派生类的protected成员

注:无论何种继承方式,基类的private成员都不能被派生类访问。从上面的表中可以看出,声明为public的方法和属性可以被随意访问;声明为protected的方法和属性只能被类本身和其子类访问;而声明为private的方法和属性只能被当前类的对象访问。

1. 友元函数必须在类中进行声明而在类外定义,声明时须在函数返回类型前面加上关键字friend。友元函数虽不是类的成员函数,但它可以访问类中的私有和保护类型数据成员。

2. 虚函数在重新定义时参数的个数和类型必须和基类中的虚函数完全匹配,这一点和函数重载完全不同。

3. #include <文件名>和#include "文件名"

文件包含的两种格式中,第一种格式用来包含那些由系统提供的并放在指定子目录中的头文件;而第二种格式用来包含那些由用户自己定义的放在当前目录或其他目录下的头文件或其它源文件。

4. 数组也可以作为函数的实参和形参,若数组元素作为函数的实参,则其用法与变量相同。当数组名作为函数的实参和形参时,传递的是数组的地址。当进行按值传递的时候,所进行的值传送是单向的,即只能从实参传向形参,而不能从形参传回实参。形参的初值和实参相同,而形参的值发生改变后,实参并不变化,两者的终值是不同的。而当用数组名作为函数参数进行传递时,由于实际上实参和形参为同一数组,因此当形参数组发生变化时,实参数组也随之发生变化。

注:实参数组与形参数组类型应一致,如不一致,结果将出错;形参数组也可以不指定大小,在定义数组时数组名后面跟一个空的方括号,为了在被调用函数中处理数组元素的需要,可以另设一个参数,传递数组元素的个数。如:int sum(int array[],int n);

5. 重载、复盖和隐藏的区别?

函数的重载是指C++允许多个同名的函数存在,但同名的各个函数的形参必须有区别:形参的个数不同,或者形参的个数相同,但参数类型有所不同。

复盖(Override)是指派生类中存在重新定义的函数,其函数名、参数列、返回值类型必须同父类中的相对应被复盖的函数严格一致,复盖函数和被复盖函数只有函数体 (花括号中的部分)不同,当派生类对象调用子类中该同名函数时会自动调用子类中的复盖版本,而不是父类中的被复盖函数版本,这种机制就叫做复盖。

下面我们从成员函数的角度来讲述重载和复盖的区别。

成员函数被重载的特征有:1) 相同的范围(在同一个类中);2) 函数名字相同;3) 参数不同;4) virtual关键字可有可无。

复盖的特征有:1) 不同的范围(分别位于派生类与基类);2) 函数名字相同;3) 参数相同;4) 基类函数必须有virtual关键字。

范围规则总结/派生类 编辑

这一节补充一些有关类的新的概念:

* 二义性

* 全局名称

* 名称和限定名

* 函数的参量名称

* 构造函数初始化器

二义性

名称的使用在其范围中必须是无二义性的(直到名称的重载点)。如果这个名称表示了一个函数,那么这个函数必须是关于参量的个数和类型是无二义性的。如果名称存在着二义性,则要运用成员访问规则。

全局名称

一个对象、函数或枚举的名称如果在任何函数、类之外引入或前缀有全局单目范围操作符(::),并同时没有同任何下述的双目操作符连用。

* 范围分辨符(::)

* 对象和引用的成员选择符(.)

* 指针的成员选择符(->)

名称及限定名

同双目的范围分辨符(::)一起使用的名称叫“限定名”。在双目范围分辨符之后说明的名称必须是在该说明符左边所说明的类的成员或其基类的成员。

在成员选择符(.或->)后说明的名称必须是在该说明符左边所说明的类类型对象的成员或其基类的成员。在成员选择符的右边所说明的名称可以是任何类类型对象,只要该说明符的左边是一个类类型对象,而且该对象的类定义了一个重载的成员选择符(->),它把指针所指的对象变为特殊的类类型。

编译器按下面的顺序搜索一个名称,发现以后便停止:

1. 如果名称是在函数中使用,则在当前块范围中搜索,否则在全局范围中搜 索。

2. 向外到每一个封闭块范围中搜索,包括最外面函数范围(这将包括函数的参量)。

3. 如果名称在一个成员函数中使用,则在该类的范围中搜索该名称。

4. 在该类的基类中搜索该名称。

5. 在外围嵌套类范围(如果有)或其基类中搜索,这一搜索一直到最外层包裹的类的范围搜索之后。

6. 在全局范围中搜索。

然而你可以按如下方式改变搜索顺序:

7. 如果名称的前面有::,则强制搜索在全局范围之中。

8. 如果名称的前面有class、struct和union关键字,将强制编译器仅搜索 class,struct或union名称。

9. 在范围分辨符的左边的名称,只能是class,struct和union的名称。如果在一个静态成员函数中引用了一个非静态的成员名,将会产生一条错误消息。同样地,任何引用包围类中的非静态组员会产生一条错误消息,因为被包围的类没有包围类的this指针。

函数参量名称

函数的参量名称在函数的定义中视为在函数的最外层块的范围中。因此,它们是局部名称并且在函数结束之后,范围就消失了。

函数的参量名称是在函数说明(原型)的局部范围中,并且在说明结束以后的范围中消失。

派生类
派生类

缺省的参量名称是在参量(它们是缺省的)范围中,如前面两段描述的,然而它们不能访问局部变量和非静态类成员。缺省参量值的确定是在函数调用的时候,但它们的给定是在函数说明的原始范围中。因此成员函数的缺省参量总是在类范围中的。