登录  
 加关注
查看详情
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

面包会有的

... ...

 
 
 

日志

 
 

VC++深入详解--之复习笔记(六)   

2008-05-16 09:46:16|  分类: VC++ |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

 

新一篇: struct和typedef struct 有什么不同呢?

在学习Visual C++ 6.0编程之前,有必要复习一下C++中面向对象的一些基本概念。我们知道,C++与C相比有许多优点,主要体现在封装性(Encapsulation)、继承性(Inheritance)和多态性(Polymorphism)。封装性把数据与操作数据的函数组织在一起,不仅使程序结构更加紧凑,并且提高了类内部数据的安全性;继承性增加了软件的可扩充性及代码重用性;多态性使设计人员在设计程序时可以对问题进行更好的抽象,有利于代码的维护和可重用。Visual C++不仅仅是一个编译器,更是一个全面的应用程序开发环境,读者可以充分利用具有面向对象特性的C++语言开发出专业级的Windows应用程序。熟练掌握本章的内容,将为后续章节的学习打下良好的基础。

2.1   从结构到类

在C语言中,我们可以定义结构体类型,将多个相关的变量包装为一个整体使用。在结构体中的变量,可以是相同、部分相同,或完全不同的数据类型。在C语言中,结构体不能包含函数。在面向对象的程序设计中,对象具有状态(属性)和行为,状态保存在成员变量中,行为通过成员方法(函数)来实现。C语言中的结构体只能描述一个对象的状态,不能描述一个对象的行为。在C++中,对结构体进行了扩展,C++的结构体可以包含函数。

2.1.1 结构体的定义

下面我们看看如例2-1所示的程序(EX01.CPP)。

例2-1

#include <iostream.h>

struct point

{

    int x;

    int y;

};

void main()

{

    point pt;

    pt.x=0;

    pt.y=0;

    cout<<pt.x<<endl<<pt.y<<endl;

}

在这段程序中,我们定义了一个结构体point,在这个结构体当中,定义了两个整型的变量,作为一个点的X坐标和Y坐标。在main函数中,定义了一个结构体的变量pt,对pt的两个成员变量进行赋值,然后调用C++的输出流类的对象cout将这个点的坐标输出。

在C++中预定义了三个标准输入输出流对象:cin(标准输入)、cout(标准输出)和cerr(标准错误输出)。cin与输入操作符(>>)一起用于从标准输入读入数据,cout与输出操作符(<<)一起用于输出数据到标准输出上,cerr与输出操作符(<<)一起用于输出错误信息到标准错误上(一般同标准输出)。默认的标准输入通常为键盘,默认的标准输出和标准错误输出通常为显示器。

cin和cout的使用比C语言中的scanf和printf要简单得多。使用cin和cout你不需要去考虑输入和输出的数据的类型,cin和cout可以自动根据数据的类型调整输入输出的格式。

对于输出来说,按照例2-1中所示的方式调用就可以了,对于输入来说,我们以如下方式调用即可:

int i;

cin>>i;

 

VC++深入详解--之复习笔记(六)  - wmnmtm -  .注意:在使用cin和cout对象时,要注意箭头的方向。在输出中我们还使用了endl(end of line),表示换行,注意最后一个是字母‘l’,而不是数字1。endl相当于C语言的'\n',endl在输出流中插入一个换行,并刷新输出缓冲区。

因为用到了C++的标准输入输出流,所以我们需要包含iostream.h这个头文件,就像我们在C语言中用到了printf和scanf函数时,要包含C的标准输入输出头文件stdio.h。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .提示:在定义结构体时,一定不要忘了在右花括号处加上一个分号(;)。

我们将结构体point的定义修改一下,结果如例2-2所示:

例2-2

struct point

{

    int x;

    int y;

    void output()

    {

        cout<<x<<endl<<y<<endl;

    }

};

在point这个结构体中加入了一个函数output。我们知道在C语言中,结构体中是不能有函数的,然而在C++中,结构体中是可以有函数的,称为成员函数。这样,在main函数中就可以以如下方式调用:

void main()

{

    point pt;

    pt.x=0;

    pt.y=0;

//  cout<<pt.x<<endl<<pt.y<<endl;

    pt.output();

}

 

VC++深入详解--之复习笔记(六)  - wmnmtm -  .注意:在C++中,//......用于注释一行,/*......*/用于注释多行。

2.1.2 结构体与类

将上面例2-2所示的point结构体定义中的关键字struct换成class,得到如例2-3所示的定义。

例2-3

class point

{

     int x;

     int y;

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

};

这就是C++中的类的定义,看起来是不是和结构体的定义很类似?在C++语言中,结构体是用关键字struct声明的类。类和结构体的定义除了使用关键字“class”和“struct”不同之外,更重要的是在成员的访问控制方面有所差异。结构体默认情况下,其成员是公有(public)的;类默认情况下,其成员是私有(private)的。在一个类当中,公有成员是可以在类的外部进行访问的,而私有成员就只能在类的内部进行访问了。例如,现在设计家庭这样一个类,对于家庭的客厅,可以让家庭成员以外的人访问,我们就可以将客厅设置为public。对于卧室,只有家庭成员才能访问,我们可以将其设置为private。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .提示:在定义类时,同样不要忘了在右花括号处加上一个分号(;)。

如果我们编译例2-4所示的程序(EX02.CPP):

例2-4

#include <iostream.h>

class point

{

     int x;

     int y;

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

};

 

void main()

{

     point pt;

     pt.x=0;

     pt.y=0;

     pt.output();

}

 

 

2.2   C++的特性

下面我们将通过具体的代码演示,给读者讲解C++类的特性。所使用的C++开发工具是微软公司出品的Visual C++ 6.0,操作系统是Windows2000 Server SP4。

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 启动Microsoft Visual C++6.0,如图2.2所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 单击File菜单,选择New,如果2.3所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 在Projects选项卡下,选择Win32 Console Application,如图2.4所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 在右边的Project name:中,输入工程名EX03,单击OK按钮,如图2.5所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.2  Microsoft Visual C++6.0初始界面

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.3  选择【File\New】菜单项

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.4  选择Win32 Console Application工程类型

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.5  输入工程名

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 在Win32 Console Application-Step 1 of 1中,选择An empty project单选按钮,单击【Finish】按钮,如图2.6所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 出现一个工程信息窗口,单击【OK】按钮,如图2.7所示,这样就生成了一个空的应用程序外壳。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .        VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.6  选择An empty project选项                        图2.7  新工程信息

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 这样的应用程序外壳并不能做什么,甚至不能运行,我们还要为它加上源文件。单击【File】菜单,选择【New】;然后在Files选项卡下,选择C++ Source File,如图2.8所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.8  为程序增加C++源文件

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 在右边的File文本框中,输入文件名EX03,单击【OK】按钮,如图2.9所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.9  输入C++源文件名称

并在EX03.cpp文件中输入以下代码:

例2-5

#include <iostream.h>

class point

{

public:

     int x;

     int y;

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

};

void main()

{

     point pt;

     pt.output();

}

 

VC++深入详解--之复习笔记(六)  - wmnmtm -  .说明:在这一章中,我们所有的示例工程都通过上述方式创建。

 

VC++深入详解--之复习笔记(六)  - wmnmtm -  .提示:如果你在编译程序时出现了下面的错误,请想想错误的原因,然后参照1.5节给出的问题解决办法,解决下面的错误。

 

--------------------Configuration: EX03 - Win32 Debug--------------------

Compiling...

EX03.CPP

Linking...

LIBCD.lib(wincrt0.obj) : error LNK2001: unresolved external symbol _WinMain@16

Debug/EX03.exe : fatal error LNK1120: 1 unresolved externals

Error executing link.exe.

 

EX03.exe - 2 error(s), 0 warning(s)

 

2.2.1 类与对象

在这个程序中,我们定义了一个类point,在main函数中我们定义了一个pt对象,它的类型是point这个类。C++语言是面向对象的语言,那么,什么是类?什么是对象呢?

类描述了一类事物,以及事物所应具有的属性,例如:我们可以定义“电脑”这个类,那么作为“电脑”这个类,它应该具有显示器、主板、CPU、内存、硬盘,等等。那么什么是“电脑”的对象呢?例如,我们组装的一台具体的电脑,它的显示器是美格的,主板是华硕的,CPU是Intel的,内存是现代的,硬盘用的是希捷的,也就是“电脑”这个类所定义的属性,在我们购买的这台具体的电脑中,有了具体的值。

这台具体的电脑就是我们“电脑”这个类的一个对象。我们还经常听到“类的实例”,什么是“类的实例”呢?实际上,类的实例和类的对象是一个概念。

对象是可以销毁的。例如,我们购买的这台电脑,它是可以被损毁的。而类是不能被损毁的,我们不能说把电脑毁掉,“电脑”类是一个抽象的概念。

2.2.2 构造函数

按下键盘上的F7功能键编译例2-5的代码,然后按下键盘上的Ctrl+F5执行程序,出现如图2.10所示的运行结果。

从图中可以看到,输出了两个很大的负数。这是因为在构造pt对象时,系统要为它的成员变量x和y分配内存空间,而在这个内存空间中的值是一个随机值,在程序中我们没有给这两个变量赋值,因此输出时就看到了如图2.10所示的结果。这当然不是我们所期望的,作为一个点的两个坐标来说,应该有一个合理的值。为此,我们想到定义一个初始化函数,用它来初始化x和y坐标。这时程序的代码如例2-6所示,其中加灰显示的部分为新添加的代码。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.10  EX03程序的运行结果

例2-6

#include <iostream.h>

class point

{

public:

     int x;

     int y;

     void init()

     {

          x=0;

          y=0;

     }

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

};

void main()

{

     point pt;

     pt.init();

     pt.output();

}

然而,对于我们定义的init函数,在编写程序时仍然有可能忘记调用它。那么,能不能在我们定义pt这个对象的同时,就对pt的成员变量进行初始化呢?在C++当中,给我们提供了一个构造函数,可以用来对类中的成员变量进行初始化。

C++规定构造函数的名字和类名相同,没有返回值。我们将init这个函数删去,增加一个构造函数point。这时程序的代码如例2-7所示,其中加灰显示的部分为新添加的代码。

例2-7

#include <iostream.h>

class point

{

public:

     int x;

     int y;

     point()    //point类的构造函数

     {

          x=0;

          y=0;

     }

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

};

 

void main()

{

     point pt;

     pt.output();

}

在程序中,point这个构造函数没有任何返回值。我们在函数内部对x和y变量进行了初始化,按F7编译代码,按Ctrl+F5执行程序,可以看到输出结果是两个0。

构造函数的作用是对对象本身做初始化工作,也就是给用户提供初始化类中成员变量的一种方式。可以在构造函数中编写代码,对类中的成员变量进行初始化。在例2-7的程序中,当在main函数中执行“point pt”这条语句时,就会自动调用point这个类的构造函数,从而完成对pt对象内部数据成员x和y的初始化工作。

如果一个类中没有定义任何的构造函数,那么C++编译器在某些情况下会为该类提供一个默认的构造函数,这个默认的构造函数是一个不带参数的构造函数。只要一个类中定义了一个构造函数,不管这个构造函数是否是带参数的构造函数,C++编译器就不再提供默认的构造函数。也就是说,如果为一个类定义了一个带参数的构造函数,还想要无参数的构造函数,则必须自己定义。

VC++深入详解--之复习笔记(六)  - wmnmtm -  . 知识点 国内很多介绍C++的图书,对于构造函数的说明,要么是错误的,要么没有真正说清楚构造函数的作用。在网友backer的帮助下,我们参看了ANSI C++的ISO标准,并从汇编的角度试验了几种主流编译器的行为,对于编译器提供默认构造函数的行为得出了下面的结论:

如果一个类中没有定义任何的构造函数,那么编译器只有在以下三种情况,才会提供默认的构造函数:

1.如果类有虚拟成员函数或者虚拟继承父类(即有虚拟基类)时;

2.如果类的基类有构造函数(可以是用户定义的构造函数,或编译器提供的默认构造函数);

3.在类中的所有非静态的对象数据成员,它们所属的类中有构造函数(可以是用户定义的构造函数,或编译器提供的默认构造函数)。

2.2.3 析构函数

当一个对象的生命周期结束时,我们应该去释放这个对象所占有的资源,这可以利用析构函数来完成。析构函数的定义格式为:~类名(),如:~point()。

析构函数是“反向”的构造函数。析构函数不允许有返回值,更重要的是析构函数不允许带参数,并且一个类中只能有一个析构函数。析构函数的作用正好与构造函数相反,析构函数用于清除类的对象。当一个类的对象超出它的作用范围,对象所在的内存空间被系统回收,或者在程序中用delete删除对象时,析构函数将自动被调用。对一个对象来说,析构函数是最后一个被调用的成员函数。

根据析构函数的这种特点,我们可以在构造函数中初始化对象的某些成员变量,为其分配内存空间(堆内存),在析构函数中释放对象运行期间所申请的资源。

例如,下面这段程序:

class Student

{

private:

    char *pName;

public:

    Student()

    {

        pName=new char[20];

}

~Student()

{

        delete[] pName;

}

};

在Student类的构造函数中,给字符指针变量pName在堆上分配了20个字符的内存空间,在析构函数中调用delete,释放在堆上分配的内存。如果没有delete[] pName这句代码,当我们定义一个Student的对象,在这个对象生命周期结束时,在它的构造函数中分配的这块堆内存就会丢失,造成内存泄漏。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .提示:在类中定义成员变量时,不能直接给成员变量赋初值。例如:

class point

{

   int x=0;//错误,此处不能给变量x赋值。

   int y;

};

 

2.2.4 函数的重载

我们希望在构造pt这个对象的同时,传递x坐标和y坐标的值。可以再定义一个构造函数,如例2-8所示。

例2-8

#include <iostream.h>

class point

{

public:

     int x;

     int y;

     point()

     {

          x=0;

          y=0;

     }

     point(int a, int b)

     {

          x=a;

          y=b;

     }

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

};

 

 

void main()

{

     point pt(5,5);

     pt.output();

}

在这个程序中,有两个构造函数,它们的函数名是一样的,只是参数的类型和个数不一样。这在C语言中是不允许的,而在C++中上述定义是合法的,这就是C++中函数的重载(overload)。当执行main函数中的point pt(5,5)这条语句时,C++编译器将根据参数的类型和参数的个数来确定执行哪一个构造函数,在这里即执行point(int a, int b)这个函数。

重载构成的条件:函数的参数类型、参数个数不同,才能构成函数的重载。分析以下两种情况,是否构成函数的重载。

第一种情况:(1)void output();

(2)int output();

第二种情况:(1)void output(int a,int b=5);

(2)void output(int a);

对于第一种情况,当我们在程序中调用output()函数时,读者认为应该调用的是哪一个函数呢?要注意:只有函数的返回类型不同是不能构成函数的重载的。

对于第二种情况,当我们在程序中调用output(5)时,应该调用的是哪一个函数呢?调用(1)的函数可以吗?当然是可以的,因为(1)的函数第二个参数有一个默认值,因此可以认为调用的是第一个函数;当然也可以是调用(2)的函数。由于调用有歧义,因此这种情况也不能构成函数的重载。在函数重载时,要注意函数带有默认参数的这种情况。

2.2.5  this指针

我们再看例2-9所示的这段代码(EX04.CPP):

例2-9

#include <iostream.h>

class point

{

public:

     int x;

     int y;

     point()

     {

          x=0;

          y=0;

     }

     point(int a,int b)

     {

          x=a;

          y=b;

     }

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

     void input(int x,int y)

     {

          x=x;

          y=y;

     }

};

void main()

{

     point pt(5,5);

     pt.input(10,10);

     pt.output();

}

我们在point类中定义了一个input函数。在这个函数中,用参数x和参数y分别给成员变量x和y进行了赋值。在main函数中,先调用pt对象的input函数,接收用户输入的坐标值,然后调用output函数输出pt对象的坐标值。

读者可以思考一下这段程序的运行结果,然后编译运行,看看结果和你所思考的结果是一样的吗?

有的读者可能会认为在input(int x, int y)函数中,利用形参x和形参y对point类中的成员变量x和y进行了赋值,然而事实是这样吗?因为变量的可见性,point类的成员变量x和y在input(int x, int y)这个函数中是不可见的,所以,我们实际上是将形参x的值赋给了形参x,将形参y的值赋给了形参y,根本没有给point类的成员变量x和y进行赋值,程序运行的结果当然就是“5,5”了。

如何在input(int x, int y)这个函数中对point类的成员变量x和y进行赋值呢?有的读者马上就想到,将input函数的参数名改一下不就可以了吗?比如:将函数改为input(int a, int b),当然,这也是一种解决办法。如果我们不想改变函数的参数名,那么又如何去给point类的成员变量x和y进行赋值呢?

在这种情况下,可以利用C++提供的一个特殊的指针——this来完成这个工作。this指针是一个隐含的指针,它是指向对象本身的,代表了对象的地址。一个类所有的对象调用的成员函数都是同一个代码段,那么,成员函数又是怎么识别属于不同对象的数据成员呢?原来,在对象调用pt.input(10,10)时,成员函数除了接收2个实参外,还接收到了pt对象的地址,这个地址被一个隐含的形参this指针所获取,它等同于执行this=&pt。所有对数据成员的访问都隐含地被加上了前缀this->。例如:x=0; 等价于this->x=0。

利用this指针,我们重写input(int x, int y)函数,结果如例2-10所示。

例2-10

#include <iostream.h>

class point

{

public:

     int x;

     int y;

     point()

     {

          x=0;

          y=0;

     }

     point(int a,int b)

     {

          x=a;

          y=b;

     }

     void output()

     {

          cout<<x<<endl<<y<<endl;

     }

     void input(int x,int y)

     {

          this->x=x;

          this->y=y;

     }

};

void main()

{

     point pt(5,5);

     pt.input(10,10);

     pt.output();

}

再编译运行,此时的结果就如预期所料了。

2.2.6 类的继承

1.继承

我们定义一个动物类,对于动物来说,它应该具有吃、睡觉和呼吸的方法。

class animal

{

public:

    void eat()

    {

        cout<<"animal eat"<<endl;

    }

    void sleep()

    {

        cout<<"animal sleep"<<endl;

    }

    void breathe()

    {

        cout<<"animal breathe"<<endl;

    }

};

我们再定义一个鱼类,对于鱼来说,它也应该具有吃、睡觉和呼吸的方法。

class fish

{

public:

     void eat()

     {

          cout<<"fish eat"<<endl;

     }

     void sleep()

     {

          cout<<"fish sleep"<<endl;

     }

     void breathe()

     {

          cout<<"fish breathe"<<endl;

     }

};

如果我们再定义一个绵羊类,对于绵羊来说,它也具有吃、睡觉和呼吸的方法,我们是否又重写一遍代码呢?既然鱼和绵羊都是动物,是否可以让鱼和绵羊继承动物的方法呢?在C++中,提供了一种重要的机制,就是继承。类是可以继承的,我们可以基于animal这个类来创建fish类,animal称为基类(Base Class,也称为父类),fish称为派生类(Derived Class,也称为子类)。派生类除了自己的成员变量和成员方法外,还可以继承基类的成员变量和成员方法。

重写animal和fish类,让fish从animal继承,代码如例2-11所示(EX05.CPP)。

例2-11

#include <iostream.h>

class animal

{

public:

     void eat()

     {

          cout<<"animal eat"<<endl;

     }

     void sleep()

     {

          cout<<"animal sleep"<<endl;

     }

     void breathe()

     {

          cout<<"animal breathe"<<endl;

     }

};

class fish:public animal

{  

};

void main()

{

     animal an;

     fish fh;

     an.eat();

     fh.eat();

}

虽然fish类没有显式地编写一个方法,但fish从animal已经继承eat、sleep、breathe方法,我们通过编译运行可以看到结果。

下面,我们在animal类和fish类中分别添加构造函数和析构函数,然后在main函数中定义一个fish类的对象fh,看看在构造fish类的对象时,animal类的构造函数是否被调用;如果调用,animal类和fish类的构造函数的调用顺序是怎样的。完整代码如例2-12所示(EX06.CPP)。

例2-12

#include <iostream.h>

class animal

{

public:

     animal()

     {

          cout<<"animal construct"<<endl;

     }

     ~animal()

     {

          cout<<"animal destruct"<<endl;

     }

     void eat()

     {

          cout<<"animal eat"<<endl;

     }

     void sleep()

     {

          cout<<"animal sleep"<<endl;

     }

     void breathe()

     {

          cout<<"animal breathe"<<endl;

     }

};

class fish:public animal

{

public:

     fish()

     {

          cout<<"fish construct"<<endl;

     }

     ~fish()

     {

          cout<<"fish destruct"<<endl;

     }

};

void main()

{

     fish fh;

}

编译运行,出现如图2.11所示的结果。

可以看到当构造fish类的对象fh时,animal类的构造函数也要被调用,而且在fish类的构造函数调用之前被调用。当然,这也很好理解,没有父亲就没有孩子,因为fish类从animal类继承而来,所以在fish类的对象构造之前,animal类的对象要先构造。在析构时,正好相反。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.11  EX06.CPP程序的运行结果

2.在子类中调用父类的带参数的构造函数

下面我们修改一下animal类的构造函数,增加两个参数height和weight,分别表示动物的高度和重量。代码如例2-13所示。

例2-13

#include <iostream.h>

class animal

{

public:

     animal(int height, int weight)

     {

         cout<<"animal construct"<<endl;

     }

     ~animal()

     {

         cout<<"animal destruct"<<endl;

     }

     void eat()

     {

         cout<<"animal eat"<<endl;

     }

     void sleep()

     {

         cout<<"animal sleep"<<endl;

     }

     void breathe()

     {

         cout<<"animal breathe"<<endl;

     }

};

class fish:public animal

{

public:

     fish()

     {

         cout<<"fish construct"<<endl;

     }

     ~fish()

     {

         cout<<"fish destruct"<<endl;

     } 

};

void main()

{

     fish fh;

}

当我们编译这个程序时,就会出现如下错误:

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

那么这个错误是如何出现的呢?当我们构造fish类的对象fh时,它需要先构造animal类的对象,调用animal类的默认构造函数(即不带参数的构造函数),而在我们的程序中,animal类只有一个带参数的构造函数,在编译时,因找不到animal类的默认构造函数而出错。

因此,在构造fish类的对象时(调用fish类的构造函数时),要想办法去调用animal类的带参数的构造函数,那么,我们如何在子类中向父类的构造函数传递参数呢?可以采用如例2-14所示的方式,在构造子类时,显式地去调用父类的带参数的构造函数。

例2-14

#include <iostream.h>

class animal

{

public:

    animal(int height, int weight)

    {

        cout<<"animal construct"<<endl;

    }

    …

};

class fish:public animal

{

public:

    fish():animal(400,300)

    {

        cout<<"fish construct"<<endl;

    }

    …

};

void main()

{

    fish fh;

}

注意程序中以粗体显示的代码。在fish类的构造函数后,加一个冒号(:),然后加上父类的带参数的构造函数。这样,在子类的构造函数被调用时,系统就会去调用父类的带参数的构造函数去构造对象。这种初始化方式,还常用来对类中的常量(const)成员进行初始化,如下面的代码所示:

class point

{

public:

     point():x(0),y(0)

private:

     const int x;

     const int y;

};

当然,类中普通的成员变量也可以采取此种方式进行初始化,然而,这就没有必要了。

3.类的继承及类中成员的访问特性

在类中还有另外一种成员访问权限修饰符:protected。下面是public,protected,private三种访问权限的比较:

n public定义的成员可以在任何地方被访问。

n protected定义的成员只能在该类及其子类中访问。

n private定义的成员只能在该类自身中访问。

对于继承,也可以有public、protected或private这三种访问权限去继承基类中的成员,例如,例2-14所示代码中,fish类继承animal类,就是采用public的继承方式。如果在定义派生类时没有指定如何继承访问权限,则默认为private。如果派生类以private访问权限继承基类,则基类中的成员在派生类中都变成了private类型的访问权限。如果派生类以public访问权限继承基类,则基类中的成员在派生类中仍以原来的访问权限在派生类中出现。如果派生类以protected访问权限继承基类,则基类中的public和protected成员在派生类中都变成了protected类型的访问权限。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .注意:基类中的private成员不能被派生类访问,因此,private成员不能被派生类所继承。

4.多重继承

如同该名字中所描述的,一个类可以从多个基类中派生。在派生类由多个基类派生的多重继承模式中,基类是用基类表语法成分来说明的,多重继承的语法与单一继承很类似,只需要在声明继承的多个类之间加上逗号来分隔,定义形式为:

class派生类名:访问权限 基类名称,访问权限 基类名称,访问权限 基类名称

{

       ……

};

例如B类是由类C和类D派生的,可按如下方式进行说明:

class B:public C, public D

{

       ……

}

基类的说明顺序一般没有重要的意义,除非在某些情况下要调用构造函数和析构函数时,在这样的情况下,会有一些影响。

n由构造函数引起的初始化发生的顺序。如果你的代码依赖于B的D部分要在C部分之前初始化,则此说明顺序将很重要,你可以在继承表中把D类放到C类的前面。初始化是按基类表中的说明顺序进行初始化的。

n激活析构函数以做清除工作的顺序。同样,当类的其他部分正在被清除时,如果某些特别部分要保留,则该顺序也很重要。析构函数的调用是按基类表说明顺序的反向进行调用的。

虽然,多重继承使程序编写更具有灵活性,并且更能真实地反映现实生活,但由此带来的麻烦也不小。我们看例2-15所示的程序(EX07.CPP):

例2-15

1. #include <iostream.h>

2. class B1

3. {

4. public:

5.     void output();

6. };

7. class B2

8. {

9. public:

10.     void output();

11.};

12.void B1::output()

13.{

14.     cout<<"call the class B1"<<endl;

15.}

16.void B2::output()

17.{

18.     cout<<"call the class B2"<<endl;

19.}

20.

21.class A:public B1,public B2

22.{

23.public:

24.     void show();

25.};

26.void A::show()

27.{

28.     cout<<"call the class A"<<endl;

29.}

30.void main()

31.{

32.     A a;

        a.output();         //该语句编译时会报错

33.     a.show();

34.}

例2-15的程序乍一看,好像没有错误,但是,编译时就会出错。原因何在?由第21行代码我们知道派生类A是从基类B1和B2多重继承而来的,而基类B1和B2各有一个output()函数,在第33行,当类A的对象a要使用a.output()时,编译器无法确定用户需要的到底是哪一个基类的output()函数,而产生'A::output' is ambiguous的错误信息,请读者注意。

2.2.7 虚函数与多态性、纯虚函数

1.虚函数与多态性

因为鱼的呼吸是吐泡泡,和一般动物的呼吸不太一样,所以我们在fish类中重新定义breathe方法。我们希望如果对象是鱼,就调用fish类的breathe()方法,如果对象是动物,那么就调用animal类的breathe()方法。程序代码如例2-16所示(EX08.CPP)。

例2-16

#include <iostream.h>

class animal

{

public:

     void eat()

     {

          cout<<"animal eat"<<endl;

     }

     void sleep()

     {

          cout<<"animal sleep"<<endl;

     }

     void breathe()

     {

          cout<<"animal breathe"<<endl;

     }

};

class fish:public animal

{

public:

     void breathe()

     {

          cout<<"fish bubble"<<endl;

     }

};

 

void fn(animal *pAn)

{

     pAn->breathe();

}

void main()

{

     animal *pAn;

     fish fh;

     pAn=&fh;

     fn(pAn);

}

我们在fish类中重新定义了breathe()方法,采用吐泡泡的方式进行呼吸。接着定义了一个全局函数fn(),指向animal类的指针作为fn()函数的参数。在main()函数中,定义了一个fish类的对象,将它的地址赋给了animal类的指针变量pAn,然后调用fn()函数。看到这里,我们可能会有些疑惑,照理说,C++是强类型的语言,对类型的检查应该是非常严格的,但是,我们将fish类的对象fh的地址直接赋给指向animal类的指针变量,C++编译器居然不报错。这是因为fish对象也是一个animal对象,将fish类型转换为animal类型不用强制类型转换,C++编译器会自动进行这种转换。反过来,则不能把animal对象看成是fish对象,如果一个animal对象确实是fish对象,那么在程序中需要进行强制类型转换,这样编译才不会报错。

读者可以猜想一下例2-16运行的结果,输出的结果应该是“animal breathe”,还是“fish bubble”呢?

运行这个程序,你将看到如图2.12所示的结果。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.12  EX09程序的运行结果(一)

为什么输出的结果不是“fish bubble”呢?这是因为在我们将fish类的对象fh的地址赋给pAn时,C++编译器进行了类型转换,此时C++编译器认为变量pAn保存就是animal对象的地址。当在fn函数中执行pAn->breathe()时,调用的当然就是animal对象的breathe函数。

为了帮助读者更好地理解对象类型的转换,我们给出了fish对象内存模型,如图2.13所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

当我们构造fish类的对象时,首先要调用animal类的构造函数去构造animal类的对象,然后才调用fish类的构造函数完成自身部分的构造,从而拼接出一个完整的fish对象。当我们将fish类的对象转换为animal类型时,该对象就被认为是原对象整个内存模型的上半部分,也就是图2.13中的“animal的对象所占内存”。当我们利用类型转换后的对象指针去调用它的方法时,自然也就是调用它所在的内存中的方法。因此,出现如图2.12所示的结果,也就顺理成章了。

现在我们在animal类的breathe()方法前面加上一个virtual关键字,结果如例2-17所示。

例2-17

#include <iostream.h>

class animal

{

public:

     void eat()

     {

          cout<<"animal eat"<<endl;

     }

     void sleep()

     {

          cout<<"animal sleep"<<endl;

     }

     virtual void breathe()

     {

          cout<<"animal breathe"<<endl;

     }

};

class fish:public animal

{

public:

     void breathe()

     {

          cout<<"fish bubble"<<endl;

     }

};

 

void fn(animal *pAn)

{

     pAn->breathe();

}

void main()

{

     animal *pAn;

     fish fh;

     pAn=&fh;

     fn(pAn);

}

用virtual关键字申明的函数叫做虚函数。运行例2-17这个程序,结果调用的是fish类的呼吸方法:

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.14  EX08程序的运行结果(二)

这就是C++中的多态性。当C++编译器在编译的时候,发现animal类的breathe()函数是虚函数,这个时候C++就会采用迟绑定(late binding)技术。也就是编译时并不确定具体调用的函数,而是在运行时,依据对象的类型(在程序中,我们传递的fish类对象的地址)来确认调用的是哪一个函数,这种能力就叫做C++的多态性。我们没有在breathe()函数前加virtual关键字时,C++编译器在编译时就确定了哪个函数被调用,这叫做早期绑定(early binding)。

C++的多态性是通过迟绑定技术来实现的,关于迟绑定技术,读者可以参看相关的书籍,在这里,我们就不深入讲解了。

C++的多态性用一句话概括就是:在基类的函数前加上virtual关键字,在派生类中重写该函数,运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类,就调用派生类的函数;如果对象类型是基类,就调用基类的函数。

2.纯虚函数

将breathe()函数申明为纯虚函数,结果如例2-18所示。

例2-18

class animal

{

public:

    void eat()

    {

        cout<<"animal eat"<<endl;

    }

    void sleep()

    {

        cout<<"animal sleep"<<endl;

    }

    virtual void breathe() = 0;

};

纯虚函数是指被标明为不具体实现的虚成员函数(注意:纯虚函数也可以有函数体,但这种提供函数体的用法很少见)。纯虚函数可以让类先具有一个操作名称,而没有操作内容,让派生类在继承时再去具体地给出定义。凡是含有纯虚函数的类叫做抽象类。这种类不能声明对象,只是作为基类为派生类服务。在派生类中必须完全实现基类的纯虚函数,否则,派生类也变成了抽象类,不能实例化对象。

纯虚函数多用在一些方法行为的设计上。在设计基类时,不太好确定或将来的行为多种多样,而此行为又是必需的,我们就可以在基类的设计中,以纯虚函数来声明此种行为,而不具体实现它。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .注意:C++的多态性是由虚函数来实现的,而不是纯虚函数。在子类中如果有对基类虚函数的覆盖定义,无论该覆盖定义是否有virtual关键字,都是虚函数。

 

2.2.8 函数的覆盖和隐藏

1.函数的覆盖

在上一节介绍多态性的时候,我们给出了下面的代码片段:

例2-19

    class animal

{

public:

        …

    virtual void breathe()

    {

        cout<<"animal breathe"<<endl;

    }

};

class fish:public animal

{

public:

    void breathe()

    {

        cout<<"fish bubble"<<endl;

    }

};

在基类animal的breathe函数前添加了virtual关键字,声明该函数为虚函数。在派生类fish中重写了breathe函数,我们注意到,fish类的breathe函数和animal类的breathe函数完全一样,无论函数名,还是参数列表都是一样的,这称为函数的覆盖(override)。构成函数覆盖的条件为:

n基类函数必须是虚函数(使用virtual关键字进行声明)。

n发生覆盖的两个函数要分别位于派生类和基类中。

n函数名称与参数列表必须完全相同。

由于C++的多态性是通过虚函数来实现的,所以函数的覆盖总是和多态关联在一起。在函数覆盖的情况下,编译器会在运行时根据对象的实际类型来确定要调用的函数。

2.函数的隐藏

我们再看例2-20的代码:

例2-20

class animal

{

public:

        …

    void breathe()

    {

        cout<<"animal breathe"<<endl;

    }

};

class fish:public animal

{

public:

    void breathe()

    {

        cout<<"fish bubble"<<endl;

    }

};

你看出来这段代码和例2-19所示代码的区别了吗?在这段代码中,派生类fish中的breathe函数和基类animal中的breathe函数也是完全一样的,不同的是breathe函数不是虚函数,这种情况称为函数的隐藏。所谓隐藏,是指派生类中具有与基类同名的函数(不考虑参数列表是否相同),从而在派生类中隐藏了基类的同名函数。

初学者很容易把函数的隐藏与函数的覆盖、重载相混淆,我们看下面两种函数隐藏的情况:

(1)派生类的函数与基类的函数完全相同(函数名和参数列表都相同),只是基类的函数没有使用virtual关键字。此时基类的函数将被隐藏,而不是覆盖(请参照上文讲述的函数覆盖进行比较)。

(2)派生类的函数与基类的函数同名,但参数列表不同,在这种情况下,不管基类的函数声明是否有virtual关键字,基类的函数都将被隐藏。注意这种情况与函数重载的区别,重载发生在同一个类中。

下面我们给出一个例子,以帮助读者更好地理解函数的覆盖和隐藏,代码如例2-21所示。

例2-21

class Base

{

public:

      virtual void fn();

};

class Derived : public Base

{

public:

      void fn(int);

};

 

class Derived2 : public Derived

{

public:

      void fn();

};

在这个例子中,Derived类的fn(int)函数隐藏了Base类的fn()函数,Derived类fn(int)函数不是虚函数(注意和覆盖相区别)。Derived2类的fn()函数隐藏了Derived类的fn(int)函数,由于Derived2类的fn()函数与Base类的fn()函数具有同样的函数名和参数列表,因此Derived2类的fn()函数是一个虚函数,覆盖了Base类的fn()函数。注意,在Derived2类中,Base类的fn()函数是不可见的,但这并影响fn函数的覆盖。

当隐藏发生时,如果在派生类的同名函数中想要调用基类的被隐藏函数,可以使用“基类名::函数名(参数)”的语法形式。例如,要在Derived类的fn(int)方法中调用Base类的fn()方法,可以使用Base::fn()语句。

有的读者可能会想,我怎样才能更好地区分覆盖和隐藏呢?实际上只要记住一点:函数的覆盖是发生在派生类与基类之间,两个函数必须完全相同,并且都是虚函数。那么不属于这种情况的,就是隐藏了。

最后,我们再给出一个例子,留给读者思考,代码如例2-22所示(EX09.CPP)。

例2-22

#include <iostream.h>

class Base

{

public:

        virtual void xfn(int i)

        {

            cout<<"Base::xfn(int i)"<<endl;

        }

 

        void yfn(float f)

        {

            cout<<"Base::yfn(float f)"<<endl;

        }

 

        void zfn()

        {

            cout<<"Base::zfn()"<<endl;

        }

};

 

class Derived : public Base

{

public:

        void xfn(int i) //覆盖了基类的xfn函数

        {

            cout<<"Drived::xfn(int i)"<<endl;

        }

 

        void yfn(int c) //隐藏了基类的yfn函数

        {

            cout<<"Drived::yfn(int c)"<<endl;

        }

 

        void zfn()      //隐藏了基类的zfn函数

        {

            cout<<"Drived::zfn()"<<endl;

        }

};

 

 

void main()

{

        Derived d;

 

        Base *pB=&d;

        Derived *pD=&d;

   

        pB->xfn(5);

        pD->xfn(5);

   

        pB->yfn(3.14f);

        pD->yfn(3.14f);

 

        pB->zfn();

        pD->zfn();

}

2.2.10  C++类的设计习惯及头文件重复包含问题的解决

在设计一个类的时候,通常是将类的定义及类成员函数的声明放到头文件(即.h文件)中,将类中成员函数的实现放到源文件(即.cpp)中。对于animal类需要animal.h和animal.cpp两个文件,同样,对于fish类需要fish.h和fish.cpp。对于main()函数,我们把它单独放到EX10.cpp文件中。

往一个现有工程添加头文件(.h文件)或源文件(.cpp文件)有两种方式:一种是在打开的工程中,单击【File】→【New】,在左边的Files标签页下,选择C++ Header File或C++ Source File,然后在右边的File文本框中,输入头文件或源文件的文件名,如animal.h或animal.cpp,单击【OK】按钮。如图2.16所示。

VC++深入详解--之复习笔记(六)  - wmnmtm -  .

图2.16  新建头文件或源文件

另一种方式是在EX10的工程目录下,单击鼠标右键,选择【新建】→【文本文档】,然后将“新建文本文档.txt”改名为“animal.h”(因.h和.cpp文件都是文本格式的文件),依同样的方法,建立animal.cpp、fish.h、fish.cpp三个文件,然后在打开的工程中,选择【P

  评论这张
 
阅读(1145)| 评论(1)

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2018