5、继承与派生6-虚基类

当某类的部分或全部直接基类是从另一个共同基类派生而来时，在这些直接基类中从上一级共同基类继承来的成员就拥有相同的名称。在派生类的对象中，这些同名数据成员在内存中同时拥有多个拷贝，同一个函数名会有多个映射。我们可以使用作用域分辨符来惟一标识并分别访问他们，也可以将共同基类设置为虚基类，这时从不同的路径继承过来的同名数据成员在内存中就只有一个拷贝，同一个函数名也只有一个映射。这样就解决了同名成员的惟一标识问题。

虚基类的声明是在派生类的定义过程中进行的，语法形式：

class 派生类名:virtual 继承方式 基类名

在多继承的情况下，虚基类关键字的作用范围和继承方式关键字相同，只对紧跟其后的基类起作用。声明了虚基类之后，虚基类的成员在进一步派生过程中和派生类一起维护同一个内存数据拷贝。

如：

有一个基类B0，声明了数据成员nV和函数fun，由B0公有派生产生了类B1和B2，与前一个例子不同的是派生时声明了B0为虚基类，再以B1、B2作为基类共同公有派生了新类D1，在派生类中我们不再添加新的同名成员，这时的D1类中，通过B1、B2两条派生路径继承来的基类B0中的成员nV和fun只有一份拷贝。

使用了虚基类之后，在派生类D1中只有唯一的数据成员nV和fun。在建立D1类对象的模块中，直接使用”对象名.成员名“方式就可以惟一标识和访问这些成员。

如：

#include<iostream>
using namespace std;
class B0
{
public:
int nV;
void fun(){cout<<"Member of B0"<<endl;}
};
class B1:virtual public B0 //B0为虚基类，派生了B1类
{
public:
int nV1;
};
class B2:virtual public B0//B0为虚基类，派生了B2类
{
public:
int nV2;

};
class D1:public B1,public B2 //派生类D1定义
{
public:
int nVd;
void fund(){cout<<"Member of D1"<<endl;}
};
int main()
{
D1 d1;
d1.nV=2;
d1.fun();

getchar();
}

结果：

Member of B0

比较一下使用作用域分辨符和虚基类技术的这两个例子，前者在派生类中拥有同名成员的多个拷贝，分别通过直接基类名来唯一标识，可以存放不同的数据、进行不同的操作。后者之维护一份成员拷贝。相比之下，前者可以容纳更多的数据，后者使用更为简洁，内存空间更为节省。

3、虚基类及其派生类构造函数

如果虚基类声明有非默认形式的（即带形参的）构造函数，并且没有声明默认形式的构造函数，事情就比较麻烦了。这时，在整个继承关系中，直接或间接继承虚基类的所有派生类，都必须在构造函数的成员初始化列表中列出对虚基类的初始化。

如：

#include<iostream>
using namespace std;
class B0
{

public:
B0(int n){nV=n;}
int nV;
void fun(){cout<<"Member of B0"<<endl;}
};
class B1:virtual public B0 //B0为虚基类，派生了B1类
{
public:
B1(int a):B0(a){}
int nV1;
};
class B2:virtual public B0//B0为虚基类，派生了B2类
{
public:
B2(int a):B0(a){}
int nV2;

};
class D1:public B1,public B2 //派生类D1定义
{
public:
D1(int a):B0(a),B1(a),B2(a){}
int nVd;
void fund(){cout<<"Member of D1"<<endl;}
};
int main()
{
D1 d1(1);
d1.nV=2;
d1.fun();

getchar();
}

建立D1类对象d1时，通过D1类的构造函数的初始化列表，不仅直接调用了虚基类构造函数B0，对从B0继承的成员nV进行了初始化，而且还调用了直接基类B1和B2的构造函数B1()和B2（）的初始化列表中也都有对基类B0的初始化。这样岂不是从虚基类继承来的成员nV初始化了三次？其实c++编译器的处理方式是，在上面程序中，将建立对象d1时，即D1是最远派生类。建立一个对象时，如果这个对象中含有虚基类继承来的成员，则虚基类的成员是由最远派生类的构造函数通过调用虚基类的构造函数进行初始化的。而且，只有最远派生类的构造函数会调用虚基类的构造函数，该派生类的其他基类对虚基类构造函数的调用都自动被忽略。

linequ.h文件（包括基类和派生类的定义）

//linequ.h文件一，类定义
//包括矩阵类Matrix和线性方程组类linequ的定义
#include<iostream>
#include<cmath>
using namespace std;
class Matrix  //基类Matrix定义
{
public:      //外部接口
    Matrix(int dims=2);//构造函数
    ~Matrix();//析构函数
    void setMatrix(double *rmatr); //矩阵赋初值
    void printM();//显示矩阵
protected:    //保护数据成员
    int index;//矩阵的维数
    double *MatrixA;//矩阵存放数组首地址
};
class Linequ :public Matrix //公有派生类Linequ定义
{
public:    //外部接口
    Linequ(int dims = 2);//构造函数
    ~Linequ();//析构函数
    void setLinequ(double *a,double *b);//方程赋值
    void printL();//显示方程
    int Solve();//全选主元高斯消去法求解方程
    void showX();//显示方程的解
private:
    double *sums;//方程右端项
    double *solu;//方程的解

};

linequ.cpp基类和派生类各成员函数的实现 

#include"linequ.h"//包含类的定义头文件
//基类成员函数的实现
void Matrix::setMatrix(double *rmatr)//设置矩阵
{
    for (int i = 0; i < index*index; i++)
        *(MatrixA + i) = rmatr[i];        //矩阵成员赋初值
}
Matrix::Matrix(int dims)        //矩阵Matrix类的构造函数
{
    index = dims;//保护数据赋值
    MatrixA = new double[index*index];//动态内存分配
}
Matrix::~Matrix()//矩阵Matrix类的析构函数
{
    delete[] MatrixA;//内存释放
}
void Matrix::printM()//显示矩阵的元素
{
    cout << "The Matrix is:" << endl;
    for (int i = 0; i < index; i++)
    {
        for (int j = 0; j < index; j++)
            cout << *(MatrixA + i*index + j) << " ";
        cout << endl;

    }
}
//派生类的成员函数的实现
Linequ::Linequ(int dims) :Matrix(dims)        //派生类Linequ的构造函数
{
    sums = new double[dims];//动态内存分配
    solu = new double[dims];
}
Linequ::~Linequ()//派生类Linequ的析构函数
{
    delete[] sums;            //释放内存
    delete[] solu;
}
void Linequ::setLinequ(double *a, double *b)    //设置线性方程组
{
    setMatrix(a);        //调用基类函数
    for (int i = 0; i < index; i++)
        sums[i] = b[i];
}
void Linequ::printL()        //显示线性方程组
{
    cout << "The Line equation is:" << endl;
    for (int i = 0; i < index; i++)
    {
        for (int j = 0; j < index; j++)
            cout << *(MatrixA + i*index + j) << " ";
        cout << sums[i]<<endl;
    }
}
void Linequ::showX()        //输出方程的解
{
    cout << "The Result is:" << endl;
    for (int i = 0; i < index; i++)
    {
        cout << "X[" << i << "]=" << solu[i] << endl;
    }
}
int Linequ::Solve()        //全选主元高斯消去法求解方程
{
    int *js, l, k, i, j, is, p, q;
    double d, t;
    js = new int[index];
    l = 1;
    for (k = 0; k <= index - 2; k++)            //消去过程
    {
        d = 0.0;//用于存放每次寻找到的最大值
        for (i = k; i <= index - 1; i++)
            for (j = k; j <= index - 1; j++)
            {
                t = fabs(MatrixA[i*index + j]);
                if (t > d)
                {
                    d = t;
                    js[k] = j; //存放最大值的列坐标
                    is = i;//存放最大值的行坐标
                }
            }
            if (d + 1.0 == 1.0)l = 0;
            else
            {
                if (js[k] != k) //交换最大值对应列与k对应的主对角位置的列
                    for (i = 0; i <= index - 1; i++)
                    {
                    p = i*index + k; q = i*index + js[k];
                    t = MatrixA[p];
                    MatrixA[p] = MatrixA[q];
                    MatrixA[q] = t;
                    }
                if (is != k)//交换最大值对应行与k对应的主对角位置的行
                {
                    for (j = k; j <= index - 1; j++)
                    {
                        p = k*index + j;
                        q = is*index + j;
                        t = MatrixA[p];
                        MatrixA[p] = MatrixA[q];
                        MatrixA[q] = t;
                    }
                    t = sums[k]; 
                    sums[k] = sums[is];
                    sums[is] = t;
                }
            }//else
            if (l == 0)
            {
                delete[] js;
                cout << "fail" << endl;
                return (0);
            }
            d = MatrixA[k*index+k];
            for (j = k + 1; j <= index - 1; j++)
            {
                p = k*index + j;
                MatrixA[p] = MatrixA[p] / d;
            }
            sums[k] = sums[k] / d;
            for (i = k + 1; i <= index - 1; i++)
            {
                for (j = k + 1; j <= index - 1; j++)
                {
                    p = i*index + j;
                    MatrixA[p] = MatrixA[p] - MatrixA[i*index + k] * MatrixA[k*index + j];
                }
                sums[i] = sums[i] - MatrixA[i*index + k] * sums[k];
            }
    }
    d = MatrixA[(index-1)*index+index-1];
    if (fabs(d) + 1.0 == 1.0)
    {
        delete[] js;
        cout << "fail" << endl;
        return (0);
    }
    solu[index - 1] = sums[index - 1] / d;        //回代过程
    for (i = index - 2; i >= 0; i--)
    {
        t = 0.0;
        for (j = i + 1; j <= index - 1; j++)
            t = t + MatrixA[i*index + j] * solu[j];
        solu[i] = sums[i] - t;
    }
    js[index - 1] = index - 1;
    for (k = index - 1; k >= 0;k--)
        if (js[k] != k)
        {
        t = solu[k];
        solu[k] = solu[js[k]];
        solu[js[k]] = t;
        }
    delete[] js;
    return (1);
}

7_9.cpp主函数

#include"linequ.h"
int main(int argc, char *agrv[])
{
    double a[] =            //方程系数矩阵
    {
        0.2368,0.2471,0.2568,1.2671,
        0.1968,0.2071,1.2168,0.2271,
        0.1581,1.1675,0.1768,0.1871,
        1.1161,0.1254,0.1397,0.1490
    };
    double b[4] =            //方程组右端项
    {1.8471,1.7471,1.6471,1.5471};
    Linequ equl(4);//定义一个四元方程组对象
    equl.setLinequ(a,b);//设置方程组
    equl.printL();//输出方程组
    if (equl.Solve())//求解方程组
        equl.showX();//输出方程组的解
    else
        cout << "Fail" << endl;
    return 0;
}