C++学习笔记(四)类和对象(下)

96
EchoIR
2017.08.01 10:05* 字数 9932

1、利用构造函数限制对象的创建

在上一节构造函数的例1中,我们提到,如果不声明默认构造函数book(),而只声明带参构造函数book(char *a, double p)的时候,语句book Alice;是无法创建对象的。无法创建的原因在上一节已经讲明,这节就不再赘述了。

不过类的构造函数的这一特性却可以用来限制对象的创建。

[例1] 还是用 book 类来说明这节的内容:

首先需要知道的是我们是在什么样的情况下才需要限制对象的创建。限制对象的创建不代表我们想禁止创建对象,只是加以限制而已,限制创建对象时能够按照我们需要的那样创建,而不能随意的创建对象。

比如例1中,我们定义了一个book类,声明对象的时候自然是为了描述某一本具体的书,这个时候如果我们直接采用book a;这样的方式创建一个对象a,编译当然是不会有问题的,毕竟系统会自动生成默认构造函数的。但是这样创建的对象a能代表什么呢?指的又是哪一本书?完全不清楚!

如果这个时候我们直接调用a.display()函数,那会发生什么就不好说了,毕竟a.price和a.title都没有初始化。这就是一个比较危险的程序了。不过肯定有人会说,不是可以通过a.setprice和a.settitle函数对两个成员变量进行赋值么?不错,确实可以这么做,但是万一给忘掉了呢?

对于这样的一个类,类的设计人员如果让book a;这样的创建对象的方式不成立,并且每次创建对象的时候就必须给书本的price和title赋值,这样问题不就解决了么?

这样的想法能实现么?回答是肯定的。我们可以通过构造函数来实现这一功能。看下面的几个类的示例。

在例2中,我们在类中声明了一个带参构造函数book(char *a, double p);,如此一来默认构造函数就不会被系统自动生成了,也即不会生成book(){}这个构造函数,如此一来创建对象book a;则会出现编译错误,要想正确创建对象则必须进行初始化,如book Alice(“Alice in Wonderland”, 29.9);。

除了此种手段之外,例3的做法也是可行的,我们将默认构造函数主动声明并定义,最关键的是将其设置为private属性,也就是说无法在类外进行访问,如此一来book a;同样会报出编译错误,只不过这一次的错误是因为访问权限的问题,此时如果想要声明对象,则还是必须通过public属性的带参构造函数book(char *a, double p);来声明对象。

根据上面的几个例子,我们将系统不会自动生成默认构造函数的情况总结如下:

1)类中显式地声明了默认构造函数,无论其属性被设置为public、private还是protected,系统都不会再自动生成默认构造函数了。
2)类中显式地声明了其它任意一个不是默认构造函数的构造函数,系统均不会再自动生成默认构造函数。

其实这两点可以总结为一点,那就是当类中显示地声明了任意一个构造函数,系统均不会再自动生成构造函数。在例2中我们是采用第二种情况避免默认构造函数的产生,从而限制了类对象的随意创建。

在C++中之所以利用构造函数限制类对象的创建,意图已经很明显了,那就是要求程序设计人员在使用类创建对象的时候能够正确地进行初始化。

声明为private属性的构造函数,与声明为private属性的成员变量或普通成员函数一样,在类外同样是不能访问的,我们可以巧妙地使用这一点,限制类对象的随意创建。

2、转型构造函数

在前面,我们已经将构造函数划分为两类:默认构造函数(不带参数的构造函数)和带参构造函数。其中带参数的构造函数中有两种比较常见的构造函数:拷贝构造函数和转型构造函数。我们先来了解一下转型构造函数。

转型构造函数用于类型间的转换,将其它数据类型转变为类的对象类型。转型构造函数只有一个参数,如果该参数是int型,则我们是将int型对象转换为类对象,如果该参数类型为char *类型,我们则是将字符串常量转换为类对象。

例1:

在本例中Age(int a)即为一个转型构造函数,该构造函数仅有一个参数,该构造函数是将int型转换为类对象类型的。

例2:

在本例中,student类中有两个构造函数,一个是默认构造函数,另一个是转型构造函数,该构造函数将字符串常量转换为类对象类型。

假设我们在程序设计过程中有一个以类对象作为函数参数的函数,函数声明如下:

在例2中我们恰好在student类中定义了这样一个转型构造函数student(char * n);,该函数可以将字符串常量转换为student类的对象。在我们运行fun(name);语句时,编译器会自动调用转型构造函数将name转换为student类的对象,然后调用void fun(student s);函数。这一系列的过程都是编译器自动完成的,我们称此时的student类的转型构造函数student(char * n);支持隐式类型转换。之所以说是隐式的,是因为这个转型过程完全由编译器完成,无需程序设计人员显示转换类型。

隐式类型转换给程序设计人员带来了一定的便利,但是隐式类型转换可能会给我们设计的程序带来一些难以觉察的细微错误。有时候我们为了避免这种错误,我们希望直接强制关闭掉这种隐式类型转换,在C++中,通过关键字explicit可以实现该功能。

例3:

调用void fun(student s);函数则是无法通过编译的,因为fun函数的参数是student类的对象而非字符串常量,并且student类的转型构造函数被标记为explicit,因此无法隐式地将字符串常量转换为student类对象。使用explicit关键字的好处就在于将难以察觉的后期运行时可能会出现的错误提前到了编译期,如此一来改正错误就比较容易了。

3、拷贝构造函数

拷贝构造函数,顾名思义,就是通过拷贝对象的方式创建一个新对象。拷贝构造函数有两种原型(我们继续以book类来说明拷贝构造函数原型):

这两种原型都是book类对象的引用。下面一种原型则规定在创建新对象的时候不得修改被拷贝的对象。如果拷贝构造函数的参数不是对象的引用,则是不允许的。如下面这种构造函数形式则是无法编译通过的。

为什么拷贝构造函数的参数一定要是对象的引用呢?我们可以想一下,如果不是引用,而是通过传值的方式将实参传递给形参,这中间本身就要经历一次对象的拷贝的过程,而对象拷贝则必须调用拷贝构造函数,如此一来则会形成一个死循环,无解。所以拷贝构造函数的参数必须是对象的引用。

拷贝构造函数除了能有对象引用这样的参数之外,同样也能有其它参数。但是其它参数必须给出默认值。例如下面这种拷贝构造函数声明方式。

如果类的设计人员不在类中显示的声明一个拷贝构造函数,则系统会自动地为类生成一个拷贝构造函数,自动生成的拷贝构造函数功能简单,只能将源对象的所有成员变量一一复制给当前创建的对象。

例1:

在本例中的book类中就声明了一个拷贝构造函数book(book &b);当然这个拷贝构造函数跟系统默认生成的拷贝构造函数功能是一样的,也就只是实现了数据成员的对应拷贝功能。

了解了拷贝构造函数的声明及定义方式,我们再来看一下我们在设计类的时候,什么时候才需要设计拷贝构造函数,我们先来看下面一个例子,相信看完之后会有一定领会,之后再来揭晓答案。

例2:


在本例中,我们重新定义了一个Array类,可以理解为一个整形数组类,这个类中我们定义了两个成员变量:整形指针num和数组长度length。

类中定义了一个默认构造函数,声明了一个带参构造函数。默认构造函数很简单,带参构造函数则是用于将一个已有的数组全部拷贝给类对象。

除了两个构造函数之外,我们还定义四个成员函数,一个是用于修改数组中数值的setnum函数、一个打印数组中所有元素的display函数、一个返回数组首地址的函数getaddress和一个返回数组长度的函数getlength。除了默认构造函数之外和getlength函数之外,所有的函数在类外都有定义。

接下来我们看一下主函数。主函数中,我们先定义了一个数组,包含五个元素,分别是从1到5。之后用Array类创建对象arr1,并且用A数组初始化对象arr1,此时arr1对象相当于拥有一个数组,该数组包含5个元素,打印出来的结果是“1 2 3 4 5 ”,没有问题。之后用arr1对象初始化arr2对象,因为我们在类中没有显示地定义一个拷贝构造函数,因此系统会自动为我们生成一个拷贝构造函数,该拷贝构造函数的定义如下:

通过系统自动生成的拷贝构造函数完成arr2对象的创建,同样的arr2也是有5个元素的数组,打印出来的结果是“1 2 3 4 5 ”,同样没有问题。

之后我们调用成员函数setnum,将arr2对象下标为2的元素修改为8(原先是3)。此时打印arr2中数组元素,结果为“1 2 8 4 5 ”,正确,arr2第三个元素确实被修改掉了。

之后我们再调用arr1.display(),奇怪的事情发生了,它的打印结果竟然也是“1 2 8 4 5 ”!我们之前并未修改过第三个元素的值的,这是怎么一回事呢?不急,我们再来看一下最后一句“cout<

这问题是怎么产生的呢?不难想到拷贝构造函数参数为引用,系统自动生成的拷贝构造函数功能简单,只是将arr1的数组首地址直接赋值给arr2的数组首地址,也即num = a.num;这必然导致两个对象指向同一块内存。既然问题出在系统自动生成的拷贝构造函数上,自然要从拷贝构造函数上下手了。下面我们将正确的程序展示如例3。

例3:


看例3运行结果,如此一来,程序运行结果正确,而且两个对象arr1和arr2所指向的内存空间也是不一样的。我们在例3中自己定义了一个拷贝构造函数,并且开辟了一个新的空间用于存储数据。如此一来当然是不会有问题的了。本例中所介绍的是一个非常微妙的错误,在程序设计过程中,一定要加以避免。

从这个例子中我们是不是领会到了什么呢?通常,如果一个类中包含指向动态分配存储空间的指针类型的成员变量时,就应该为这个类设计一个拷贝构造函数,除了需要设计一个拷贝构造函数之外,还需要为它添加一个赋值操作符重载函数(即重载“=”操作符,这将会在操作符重载那一章加以介绍)。

由于类会自动生成拷贝构造函数,因此有些时候为了不让对象发生拷贝行为,我们可以显示声明一个拷贝构造函数,并将其设置为private属性。这跟通过将默认构造函数设置成private属性限制对象的创建时一样的道理。当然,禁止对象发生拷贝的需求较少,如果有这样的需求的话,知道还可以这么做就足够了,这是一个类设计的技巧。

4、析构函数

在创建对象的时候系统会自动调用构造函数,在对象需要被销毁的时候同样系统会自动调用一个函数,这个函数被称之为析构函数。析构函数就是用于回收创建对象时所消耗的各种资源。与构造函数类似,析构函数也是一个成员函数。析构函数与普通成员函数相比,有如下特征:

1)无返回值
2)没有参数,不能被重载,因此一个类也只能含有一个析构函数
3)函数名必须为“~类名”的形式,符号“~”与类名之间可以有空格

在上一节的Array类中,我们没有在类中声明析构函数,在此,我们将其补全如下。

例1:


这个例子,现在是一个完整的例子,在这个例子中,我们为其增添了一个析构函数~Array,该函数在main函数退出前被系统自动调用,用于释放num所指向的内存空间。因为有两个对象,因此最终析构函数被调用了两次。

说到析构函数,则其调用顺序则不得不介绍一下了。析构函数与构造函数调用顺序是反转过来的,先调用构造函数的后调用构造函数。我们通过下面的例子来加以说明。

例2:

从这个程序运行不难看出,析构函数的调用顺序与构造函数调用顺序正好是相反的,为了方便记忆,我们可以将之理解为一个栈,先入后出。

类的构造函数负责对象完成初始化及其它相关操作,而析构函数则用于销毁对象时完成相应的资源释放工作。在设计类过程中,我们建议为每个带有成员变量的类设计一个默认构造函数,其它构造函数及析构函数则可以视情况再定。

5、常量指针this

在每一个成员函数中都包含一个常量指针,我们称其为this指针,该指针指向调用本函数的对象,其值为该对象的首地址。通过该指针,我们可以在成员函数的函数体内访问对象。其中this是C++的一个关键字。

例1:


如例1程序所示,该例向我们展示了this指针的使用方法。当然在我们在实际的程序设计中并不需要如此,这样写未免太麻烦了,例1只是做介绍this指针基本语法所用。在实际设计程序时只需要按照例2就行。

例2:

通常我们在设计成员函数时会将形参与成员变量设计成同一个名字,如例3所示,此时函数定义的时候price = price;这样的程序看起来总是有些别扭的。这个使用如果使用this指针则就能很明朗的进行区分两个price了。

如例4所示,利用this->price表明前面一个price为类中的成员变量,而后面一个price为形参中的price。this指针在此时避免命名冲突产生理解上的歧义。

在本例中,我们为book类新增了一个copy函数,即将book类对象拷贝给调用copy函数的对象,在函数体中,我们用this指针先判断被拷贝的对象的引用是否是调用该函数的对象自身,如果是的话则推出函数。在主函数中Harry.copy(Harry);就是拷贝自身,这样的事情当然是我们不希望看到的,因此直接退出函数。这在程序设计过程中也是一种常用的检测手段。

this指针是常量指针,它的值是不能被修改的,一切企图修改该指针的操作如赋值、递增、递减等都是不允许的。此外this指针只非static成员函数中才是有效的,这一点在我们介绍完static成员函数后大家就会明白为何会如此了,在此处暂时只要知道这一点就可以了。

在例6中,this指针出现在static成员函数中,编译出错。this指针只能用于非静态成员函数内。

6、类与new和delete操作符

众所周知,C++这门语言并没有其他一些语言里的垃圾回收机制,而Java有的

当我们需要为类对象动态分配存储空间时,我们应该使用C++语言提供的new与new[]操作符,而不要使用C语言提供的malloc函数。

虽然malloc函数具有分配存储空间的功能,但是这些函数除了分配存储空间外,不会调用类的构造函数。而C++语言提供的new和new[]操作符则不会如此,使用它们为对象分配存储空间的同时,它们也会调用相应的构造函数。

操作符delete和delete[]在释放对象存储空间的同时也会调用析构函数,而free函数则不会调用析构函数。

例1:

从程序运行结果不难看出malloc确实没有调用构造函数,free也没有调用析构函数。在这里可能有人会觉得这没有遵循析构函数调用顺序,其实不是这样的,因为我们在delete

t0;的语句的时候就已经要求编译器销毁t0对象了,此时其它对象还处于存活期,因此t0先走一步,调用析构函数。之后再销毁t1所指向的对象数组。

7、类与const关键字

1)const成员函数
2)const成员函数只能调用const成员函数
3)const 对象只能调用const成员函数

在类中,有时候为了避免误操作而修改了一些人们不希望被修改的数据,此时就必须借助const关键字加以限定了。借助const关键字可以定义const类型的成员变量、成员函数、常对象以及对象的常引用。

const成员变量

const成员变量其用法和普通的const变量用法相似,在定义时只需在前面加上const关键字即可。const成员变量的初始化只有唯一的一条途径:参数初始化表。这个在前面已经提到过,不记得的话可以再去翻看参数初始化表那一小节。

const成员函数

const成员函数可以使用类中的所有成员变量,但是不能修改变量的值,这种措施主要还是为了保护数据而设置的。

我们来看一下下面的例子,例1依然是前面见过多次的book类,不过已经将与const成员函数不相关的代码都去掉了。在类中定义了两个构造函数及四个普通的成员函数,其功能分别是设置成员变量和获得成员变量。但这个book类与前面不相同的是在getprice函数和gettitle函数声明后面多了const关键字,这就是const成员函数,也可以成为常成员函数。常成员函数就是在声明和定义的时候在函数头部的结尾加上const关键字。注意在定义函数的时候const关键字依然是不能少的,具体可以参见例1中getprice和gettitle函数的定义。

为什么要将这两个函数定义成常成员函数呢?这两个函数的功能我们知道就是为了返回price和title的,功能单一,并且不希望修改这两个变量的,如此,定义成常成员函数是非常保险的一种做法,可以避免在这两个函数内部修改成员变量。如果需要修改这两个变量则只需通过setprice和settitle函数完成,因此设置为const是非常合适的。

例1:

常成员函数可以访问类中的任何成员变量,但是不能修改任何成员变量。而普通的成员函数不能访问常对象的成员变量,其它的成员变量都可以访问,普通的成员函数可以修改的成员变量也只有非const成员变量了,一旦加上了const关键字加以修饰,初始化完成后就不能被修改了。还有一点需要注意的是const成员函数是不能调用类中非const成员函数的。

const对象

const对象定义的基本语法如下:
1)const 类名 对象名(实参名);
2)类名 const 对象名(实参名);

这两种定义方式都是可以的,我们一旦将对象定义为常对象之后,该对象就只能调用类中的常成员函数了。

例2:


在本例中,我们将类中的getprice、gettitle和display三个函数都声明为了常成员函数,之后在主函数中我们定义了一个常对象Alice,Alice作为一个常对象,只能调用常成员函数,因此在调用display函数时没有问题,但是在调用setprice函数时编译报错,因为setprice不是常成员函数。

有些时候我们在程序设计过程中要求修改常对象中的某个成员变量,这个时候如果是普通的成员变量是不能被修改的。为了满足这一需求,C++提供了mutable关键字。

通过这样的声明将变量var声明为可变的成员变量,此时如果要修改常对象的该变量时,只需要通过常对象调用const成员函数修改该变量即可。

对象的const引用

在将对象作为函数参数的时候,通常我们会采用引用的方式作为函数参数。有时候为了在函数中避免对对象本身做出什么修改,在函数形参前加上const关键字。

例3:


在本例中,我们将display函数声明为顶层函数,其函数形参为book类对象的常引用,在函数内部我们首先调用public属性的setprice函数,企图修改price成员变量,编译无法通过。而在其后调用gettitle和getprice函数则没有问题,因为这些函数没有修改成员变量。

8、类与static关键字

mine:静态的应该是定义类的时候就给分配空间的,如果是静态变量,则就会有默认的值0,所以而非静态的属于对象,只有在构造对象的时候才分配空间。所以非静态的可以调用静态的,而静态的不可以调用非静态的。

到目前为止,我们设计的类中所有的成员变量和成员函数都是属于对象的,如我们在前面定义的book类,利用book类声明两个对象Alice和Harry,这两个对象均拥有各自的price和title成员变量,同时还拥有类中所有的成员函数。

除了这种情况以外,我们还有另外一种类型的成员,那就是与static结合的成员变量和成员函数。类中的成员变量或成员函数一旦与static关键字相结合,则该成员变量或成员函数就是属于类的,而不是再是属于任何一个对象的,当然任何一个对象都可以共享该成员变量及成员函数。

静态成员变量

静态成员变量声明非常简单,只需要将static关键字加在成员变量声明的前面即可,如例1所示,我们在例中声明了一个静态成员变量count,并将其设置为private属性。设计这个count变量主要是为了统计当前存活的student类对象的个数,当然这个类并不完善,通过这个例子,我们可以了解静态成员变量的声明语法。

请仔细查看例2的代码,这段代码虽然与例1相比只是增添了一行代码,却是有几处需要我们特别留心。首先静态成员变量的定义必须在任何程序块之外;其次调用该变量的时候可以直接用类名加上域解析符“::”加上变量名的形式,这是静态成员变量特有的引用方式;在类外部进行定义的时候static关键字是不需要的。

在C++语法中规定静态成员变量会被默认初始化为0,类外定义可有可无。而实际上在一些编译器中,如果不加上类外的定义,会出现一些不可知的情况,故在实际设计程序的时候最好还是将类外定义加上。

静态成员变量不会影响类及其对象的大小,也即sizeof结果不会受到影响。在上面的例2中,无论我们是否声明count这个静态成员变量,sizeof(student)或者sizeof(student的对象)其结果都是不会变的。

静态成员变量属于类而不属于任何一个对象,如此一来可以实现数据共享功能,如例3所示。

在本例中,为了方便样式static成员变量的共享特性,我们将静态成员变量设为public属性,如此一来在类外可以方便调用。在类外我们先将静态成员变量进行定义,并初始化为1。在主函数中我们为test类定义了三个对象,分别为one、two和three。之后分别用类名和对象名调用该静态成员变量修改其值,并各自调用的结果打印出来。从程序运行结果可以看出,四种调用静态成员变量的方法,其值都是相等的,如果其中有任何一个修改该静态成员变量,所有其他的调用静态成员变量都会跟着一起改变。这就是静态成员变量的共享特性,静态成员变量不属于任何对象,但是可以通过对象访问静态成员变量。静态成员变量属于类,因此可以通过类来调用静态成员变量。静态成员变量如果被设置为private或protected属性,则在类外同样无法访问,但定义该变量的时候却不受此限制,如例2所示,虽然静态成员变量count为private属性,但是它在类外定义的时候不受private限制。

静态成员函数

在类内除了能用static声明静态成员变量外,同样可以使用static声明静态成员函数,静态成员函数只能访问static成员变量。

例4:

在本例程中,类test内有一个静态成员变量num,一个普通成员变量plus,这两个变量都是private属性,成员函数有一个构造函数,两个普通成员函数和两个静态成员函数。在构造函数中,我们引用了静态成员变量num,这是允许的,同样在setnum函数中,同样引用了静态成员变量num,这个也是允许的。然而在add函数中我们不仅引用了静态成员变量num,同时还访问了非静态成员变量plus,而这是不允许的。静态成员函数只能访问静态成员变量,而不能访问非静态成员变量。普通成员函数(包括构造函数和析构函数)既可以访问普通成员变量,同时又可以访问静态成员变量。

访问静态成员变量和静态成员函数均有两种方式,其一是和普通的成员变量成员函数相同,通过对象来访问,其二则是可以通过类名加上域解析操作符访问。当然访问过程中仍然要遵循private、protected和public关键字的访问权限限定。访问静态成员变量和静态成员函数首选的方法是通过类来访问,毕竟静态成员变量和静态成员函数都是属于类的,与类相关联,而不是属于类的对象。普通成员变量或成员函数不可以通过类来访问。由于静态成员变量和静态成员函数都是属于类,而不是属于对象,因此静态成员函数内部也不存在this指针,因为静态成员函数不属于对象。

在静态成员函数内部可以声明静态变量,注意不是静态成员变量。如果在静态成员函数内部声明一个静态变量,则该类的所有对象将共享这个变量。

例5:

为了直截了当地说明这个问题,我们只在类test中声明了一个静态成员函数add,并且在类外对这个函数进行了定义。注意,在类外定义静态成员函数是不需要static关键字的。在add函数内部我们定义了一个静态变量num,并且初始化为0,为了增强对比效果,我们又定义了一个普通的变量count。在主函数中定义了三个变量,分别调用静态成员函数,结果num值打印结果是累加的,而count则每次都是从0开始的,并不是累加的。通过对比我们很容易看出,static是被这三个对象同时共享的,三个对象一份数据。

9、友元函数和友元类

通过friend关键字,我们可以将不属于当前类的一个函数在当前类中加以声明,该函数便可以成为当前类的友元函数。

例1:

在本例中,display是一个顶层函数,在book类中,我们借助friend关键字将其声明为友元函数,结果,在display函数体内,我们就能访问private属性的title和price成员变量。这就是友元函数的作用。友元函数可以访问这个类中的私有成员。如果这个display函数不是book类的友元函数,则在函数体中还必须调用public属性的成员函数。在此例中需要注意的是友元函数的形参是类对象的引用,同时在访问私有成员变量时必须要加上对象名。

除了顶层函数可以被定义为友元函数之外,其它类的成员函数同样可以声明为本类的友元函数,如例2所示。

例2:


在本例中定义了两个类time和date,在time类中有hour、minute和second三个成员变量,分别代表时分秒,在date类中有year、month和day三个成员变量,分别代表年月日信息。为了能够共同显示年月日时分秒信息,我们在date类中声明了一个display函数,并且将该函数设置为time类的友元函数,如此一来,该函数既能访问date类中的私有成员变量,同时又能访问time类中的私有成员变量,打印时间自然不在话下

这个例子有几点需要注意一下。首先要注意的是date类的定义必须出现在time类之前,这么做是为了使得display函数的函数声明能够在声明为友元函数之前。其次,display函数的形参为time类对象的引用,而time类又必须定义在date类之后,如此一来只能先将time类声明在date类之前了,如class time;这一语句即是为了声明time类。第三点就是需要将display函数的定义放到time类定义的后面,这是因为display函数中必须用到time类中的私有成员变量,因此在使用之前,这些成员变量必须先声明出来。这三个需要注意顺序的地方需要大家特别关注一下,顺序一定不能搞错了,否则都是无法通过编译的。(mine:就算是被定义了友元函数,但是属于哪个,则就被哪个调用,只是可以访问别人的私有变量)

无论是类的成员函数还是顶层函数,它们都是可以被多个类声明为友元函数的,如此一来就可以访问多个类中的私有成员变量,但是为了保证数据的安全,友元函数的使用宁缺毋滥。

除了可以利用friend关键字声明友元函数之外,我们还可以将其它类声明为当前类的友元类。友元类声明的语法非常简单,即为“friend 类名;”。

例3:


在本例中,我们将date类声明为time类的友元类,则此时date类中的所有成员函数都将转化为time类的友元函数,可以访问time类中的所有成员。毫无疑问,date类中display函数同样也会成为time类的友元,因此利用time类对象t的引用便可以访问time类的私有成员变量了。此函数中类的声明及定义、函数的声明及定义位置同样需要注意。

关于友元还有几点需要注意:

1)例3中我们将date类声明为time类的友元类,此时date类中的所有函数都将成为time类的友元函数。
2)date类是time类的友元类,但是time类不是date类的友元类。友元关系是单向的,而不是双向的。如果需要将time类也声明名为date类的友元类,则需要另外在date类中声明。(我是你的朋友,才可以访问你的私有,并不是说你也就是我的朋友,你也可以访问我的)
3)友元关系不能传递,假设A类是B类的友元类,B类是C类的友元类,这两点并不能得出A类是C类的友元类。
4)友元类会破坏数据的安全性,使用时宁缺毋滥。如果不是能够极大提高程序运行效率的情况,最好不要用友元。

C++