C++学习从零开始(六)

　　再看main函数，先通过ABC a;定义了一个变量，由于要在栈上 调配一块内存，即 缔造了一个数字( 缔造装数字的内存也就招致 缔造了数字，由于内存不能不装数字)，进而 缔造了一个ABC的实例，进而调用ABC的 构造函数 。由于这里没有给出参数(后面 注明)，

　　 因此调用了ABC::ABC()，进而a.a为1，a.pF和a.count都为0 。接着定义了变量r，但由于它是ABC&，所以并没有在栈上 调配内存，进而没有 缔造实例而没有调用ABC::ABC 。接着调用a.Do， 调配了一块内存并把首地址放在a.pF中 。

　　 留神上面变量b的定义，其 使用了之前提到的函数式初始化 模式 。它通过函数调用的 格局调用了ABC的 构造函数ABC::ABC( long, long )以初始化ABC的实例b 。 因此b.a为10，b.count为30，b.pF为一内存块的首地址 。但要 留神这种初始化 模式和之前提到的“{}” 模式的不同，前者是进行了一次函数调用来初始化，而后者是编译器来初始化(通过生成必要的代码) 。由于不调用函数，所以速度要稍快些(关于函数的开销在《C++从零开始(十五)》中 注明) 。还应 留神不能ABC b = { 1, 0, 0 };，由于 构造ABC已经定义了两个 构造函数，则它不得不 使用函数式初始化 模式初始化了，不能再通过“{}” 模式初始化了 。上面的b在一对大括号内， 回顾前面提过的变量的作用域， 因此当程序运行到ABC *p = new ABC[10];时，变量b已经消逝了(超出了其作用域)，即其所 调配的内存语法上已经 开释了(实际由于是在栈上，其并没有被 开释)，进而调用ABC的析构函数，将b在ABC::ABC( long, long )中 调配的内存 开释掉以实现扫尾 性能 。

　　关于通过new在堆上 调配的内存，由于是new ABC[10]， 因此将 缔造10个ABC的实例，进而为每一个实例调用一次ABC::ABC()， 留神这里 无奈调用ABC::ABC( long, long )，由于new操作符一次性就 调配了10个实例所需求的内存空间，C++并没有提供语法( 比方 使用“{}”)来实现对一次性 调配的10个实例进行初始化 。接着调用了delete[] p;，这 开释刚 调配的内存，即销毁了10个实例， 因此将调用ABC的析构函数10次以进行10次扫尾工作 。

　　 留神上面申明了全局变量g_ABC，由于是申明，并不是定义，没有 调配内存， 因此未产生实例，故不调用ABC的 构造函数，而g_a由于是全局变量，C++ 保障全局变量的 构造函数在开始执行main函数之前就调用，全部全局变量的析构函数在执行完main函数之后才调用(这丝毫是编译器来实现的，在《C++从零开始(十九)》中将进一步 探讨) 。 因此g_a.ABC( 10, 34 )的调用是在a.ABC()之前， 即便它的位置在a的定义语句的后面 。而全局变量g_p的初始化的数字是通过new操作符的计算得来， 后果将在堆上 调配内存，进而生成5个ABC实例而调用了ABC::ABC()5次，由于是在初始化g_p的时候进行 调配的， 因此这5次调用也在a.ABC()之前 。由于g_p仅仅只不过记录首地址，而要 开释这5个实例就必须调用delete(不 定然，也可不调用delete依然 开释new返回的内存，在《C++从零开始(十九)》中 注明)，但上面并没有调用， 因此直到程序 完毕都将不会调用那5个实例的析构函数，那将 怎么？后面 注明 异样时再 探讨所谓的内存泄露问题 。

　　 因此 构造的意思便是刚 调配了一块内存，还未初始化，则这块内存被称作原始数据(Raw Data)，前面说过数字都必须映射成算法中的资源，则就存在数字的有效性 。 比方映射人的年龄，则这个数字就不能是负数，由于没有 意思 。所以当得到原始数据后，就应该先通过 构造函数的调用以 保障相应实例 存在正确的 意思 。而析构函数就 示意进行扫尾工作，就像上面，在某实例运作的期间(即操作此实例的代码被执行的 时代)动态 调配了一些内存，则应确保其被正确 开释 。再或者这个实例和 其余实例有关系，因确保解除关系

　　(由于这个实例马上被销毁)，如链表的某个结点用类映射，则这个结点被删除时应在其析构函数中解除它与其它结点的关系 。

　　派生和继承

　　上面我们定义了类Radiogram来映射收音机，假如又需求映射数字式收音机，它和收音机一样，即收音机 存在的东西它都 存在，不过多了自动搜台、存储台、选台和删除台的 性能 。这里提出了一个类型体系，即一个实例假如是数字式收音机，那它 定然也是收音机，即是收音机的一个实例 。 比方苹果和梨都是水果，则苹果和梨的实例 定然也是水果的实例 。这里提出三个类型：水果、苹果和梨 。其中称水果是苹果的父类(父类型)，苹果是水果的子类(子类型) 。同样，水果也是梨的父类，梨是水果的子类 。这 品种型体系是很有 意思的，由于人类便是用这种 模式来认知世界的，它十分 相符人类的思量习惯， 因此C++又提出了一种特别语法来对这种语义提供 支撑 。

　　在定义自定义类型时，在类型名的后面接一“:”， 而后接public或protected或private，接着再写父类的类型名，最终便是类型定义符“{}”及 有关书写 。

　　如下：

　　class DigitalRadiogram : public Radiogram

　　{

　　protected: double m_Stations[10];

　　public: void SearchStation(); void SaveStation( unsigned long );

　　void SelectStation( unsigned long ); void EraseStation( unsigned long );

　　};

　　上面就将Radiogram定义为了DigitalRadiogram的父类，DigitalRadiogram定义成了Radiogram的子类，被称作类Radiogram派生了类DigitalRadiogram，类DigitalRadiogram继承了类Radiogram 。

　　上面生成了5个映射元素，便是上面的4个成员函数和1个成员变量，但实际不止 。由于是从Radiogram派生， 因此还将生成7个映射，便是类Radiogram的7个成员，但名字 变迁了，全变成DigitalRadiogram:: 润饰，而不是原来的Radiogram:: 润饰，然而类型却不 变迁 。 比方其中一个映射元素的名字就为DigitalRadiogram::m_bPowerOn，类型为bool Radiogram::，映射的偏移值没变，依然为16 。同样也有映射元素DigitalRadiogram::TurnFreq，类型为void ( Radiogram:: )( double )，映射的地址依然没变，为Radiogram::TurnFreq所对应的地址 。 因此就 可以如下：

　　void DigitalRadiogram::SaveStation( unsigned long index )

　　{

　　if( index >= 10 ) return;

　　m_Station[ index ] = m_Frequency; m_bPowerOn = true;

　　}

　　DigitalRadiogram a; a.TurnFreq( 10 ); a.SaveStation( 3 );

　　上面 固然没有申明DigitalRadiogram::TurnFreq，但依然 可以调用它，由于它是从Radiogram派生来的 。 留神由于a.TurnFreq( 10 );没有书写全名， 因此实际是a.DigitalRadiogram::TurnFreq( 10 );，由于成员操作符左边的数字类型是DigitalRadiogram 。假如DigitalRadiogram不从Radiogram派生，则不会生成上面说的7个映射， 后果a.TurnFreq( 10 );将 舛误 。

　　 留神上面的SaveStation中，直接书写了m_Frequency，其等同于this->m_Frequency，由于this是

　　DigitalRadiogram*(由于在DigitalRadiogram::SaveStation的函数体内)，所以实际为this->DigitalRadiogram::m_Frequency，也 因此，假如不是派生自Radiogram，则上面将报错 。而且由类型匹配，很方便晓得：void ( Radiogram::*p )( double ) = DigitalRadiogram::TurnFreq; 。 固然这里是DigitalRadiogram::TurnFreq，但它的类型是void ( Radiogram:: )( double ) 。

　　应 留神在SaveStation中 使用了m_bPowerOn，这个在Radiogram中被定义成私有成员，也 上面通过派生而生成的7个映射元素各自的权限是什么？先看上面的派生代码：

　　class DigitalRadiogram : public Radiogram {…};

　　这里由于 使用public，被称作DigitalRadiogram从Radiogram公共继承，假如改成protected则称作 掩护继承，假如是private便是私有继承 。有什么区别？通过公共继承而生成的映射元素(指从Radiogram派生而生成的7个映射元素)，各自的权限属性不 变迁，即上面的DigitalRadiogram::m_Frequency对类DigitalRadiogram来说依然是protected，而DigitalRadiogram::m_bPowerOn也依然是private 。 掩护继承则全部的公共成员均变成 掩护成员，其它不变 。即假如 掩护继承，DigitalRadiogram::TurnFreq关于DigitalRadiogram来说将为protected 。私有继承则将全部的父类成员均变成关于子类来说是private 。 因此上面假如私有继承，则DigitalRadiogram::TurnFreq关于DigitalRadiogram来说是private的 。

　　上面 可以看得很 方便，即 无论是什么继承，其指定了一个权限，父类中 但凡高于这个权限的映射元素，都要将各自的权限减低到这个权限( 留神是对子类来说)， 而后再继承给子类 。上面向来强调“关于子类来说”，什么意思？如下：

　　struct A { long a; protected: long b; private: long c; };

　　struct B : protected A { void AB(); };

　　struct C : private B { void ABC(); };

　　void B::AB() { b = 10; c = 10; }

　　void C::ABC() { a = 10; b = 10; c = 10; AB(); }

　　A a; B b; C c; a.a = 10; b.a = 10; b.AB(); c.AB();

　　上面的B的定义等同于struct B { protected: long a, b; private: long c; public: void AB

　　(); }; 。

　　上面的C的定义等同于struct C { private: long a, b, c; void AB(); public: void ABC

　　(); };

　　 因此，B::AB中的b = 10;没有问题，但c = 10;有问题， 由于编译器看出B::c是从父类继承生成的，而它关于父类来说是私有成员， 因此子类无权 拜访， 舛误 。接着看C::ABC，a = 10;和b = 10;都没问题，由于它们关于B来说都是 掩护成员，但c = 10;将 舛误，由于C::c关于父类B来说是私有成员，没有权限，失败 。接着AB();，由于C::AB关于父类B来说是公共成员，没有问题 。