新一篇: 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;
注意：在使用cin和cout对象时，要注意箭头的方向。在输出中我们还使用了endl（end of line），表示换行，注意最后一个是字母‘l’，而不是数字1。endl相当于C语言的'\n'，endl在输出流中插入一个换行，并刷新输出缓冲区。
因为用到了C++的标准输入输出流，所以我们需要包含iostream.h这个头文件，就像我们在C语言中用到了printf和scanf函数时，要包含C的标准输入输出头文件stdio.h。
提示：在定义结构体时，一定不要忘了在右花括号处加上一个分号（;）。
我们将结构体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();
}
注意：在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。
提示：在定义类时，同样不要忘了在右花括号处加上一个分号（;）。
如果我们编译例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。
启动Microsoft Visual C++6.0，如图2.2所示。
单击File菜单，选择New，如果2.3所示。
在Projects选项卡下，选择Win32 Console Application，如图2.4所示。
在右边的Project name：中，输入工程名EX03，单击OK按钮，如图2.5所示。
图2.2 Microsoft Visual C++6.0初始界面
图2.3 选择【File\New】菜单项
图2.4 选择Win32 Console Application工程类型
图2.5 输入工程名
在Win32 Console Application-Step 1 of 1中，选择An empty project单选按钮，单击【Finish】按钮，如图2.6所示。
出现一个工程信息窗口，单击【OK】按钮，如图2.7所示，这样就生成了一个空的应用程序外壳。
图2.6 选择An empty project选项 图2.7 新工程信息
这样的应用程序外壳并不能做什么，甚至不能运行，我们还要为它加上源文件。单击【File】菜单，选择【New】；然后在Files选项卡下，选择C++ Source File，如图2.8所示。
图2.8 为程序增加C++源文件
在右边的File文本框中，输入文件名EX03，单击【OK】按钮，如图2.9所示。
图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();
}
说明：在这一章中，我们所有的示例工程都通过上述方式创建。
提示：如果你在编译程序时出现了下面的错误，请想想错误的原因，然后参照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所示，其中加灰显示的部分为新添加的代码。
图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++编译器就不再提供默认的构造函数。也就是说，如果为一个类定义了一个带参数的构造函数，还想要无参数的构造函数，则必须自己定义。
知识点 国内很多介绍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的对象，在这个对象生命周期结束时，在它的构造函数中分配的这块堆内存就会丢失，造成内存泄漏。
提示：在类中定义成员变量时，不能直接给成员变量赋初值。例如：
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类的对象要先构造。在析构时，正好相反。
图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;
}
当我们编译这个程序时，就会出现如下错误：
那么这个错误是如何出现的呢？当我们构造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类型的访问权限。
注意：基类中的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所示的结果。
图2.12 EX09程序的运行结果（一）
为什么输出的结果不是“fish bubble”呢？这是因为在我们将fish类的对象fh的地址赋给pAn时，C++编译器进行了类型转换，此时C++编译器认为变量pAn保存就是animal对象的地址。当在fn函数中执行pAn->breathe()时，调用的当然就是animal对象的breathe函数。
为了帮助读者更好地理解对象类型的转换，我们给出了fish对象内存模型，如图2.13所示。
当我们构造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类的呼吸方法：
图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;
};
纯虚函数是指被标明为不具体实现的虚成员函数（注意：纯虚函数也可以有函数体，但这种提供函数体的用法很少见）。纯虚函数可以让类先具有一个操作名称，而没有操作内容，让派生类在继承时再去具体地给出定义。凡是含有纯虚函数的类叫做抽象类。这种类不能声明对象，只是作为基类为派生类服务。在派生类中必须完全实现基类的纯虚函数，否则，派生类也变成了抽象类，不能实例化对象。
纯虚函数多用在一些方法行为的设计上。在设计基类时，不太好确定或将来的行为多种多样，而此行为又是必需的，我们就可以在基类的设计中，以纯虚函数来声明此种行为，而不具体实现它。
注意：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所示。
图2.16 新建头文件或源文件
另一种方式是在EX10的工程目录下，单击鼠标右键，选择【新建】→【文本文档】，然后将“新建文本文档.txt”改名为“animal.h”（因.h和.cpp文件都是文本格式的文件），依同样的方法，建立animal.cpp、fish.h、fish.cpp三个文件，然后在打开的工程中，选择【P
评论