C++第十四章_引入_包含(公有继承)和私有继承_is-a关系和has-a关系_私有继承_使用using重新定义获得访问权限_多重继承的问题与改进_虚基类_类模板类模板类模板_栈指针

目录

1、引入

2、包含(公有继承)和私有继承

3、is-a关系和has-a关系(复习回顾)

4、私有继承

5、使用using重新定义获得访问权限

6、多重继承MI

  6.1多重继承的引入

  6.2多重继承的问题与改进

  6.3虚基类

  6.4虚基类与二义性

7、类模板

7.1类模板简单实现

7.2栈指针

1、引入(使用公有继承)

/*关闭隐式转换的原因*/
Student doh("xiaoming",10); //使用构造函数Student(const std::string s,int n)创建Stident对象doh
doh = 5;
//如果没有关键字explict，doh=5 将调用Student(int n) : name("NUll name"),scores(n) {},并使用NUll name来设置name的值
//如果加上explicit则不会进行隐式转换

/*valarray类的介绍*/
01)需包含头文件#include <valarray>
02)使用时，需要在valarray后面加上一对尖括号并在里面写上要使用的数据类型
　  valarray<int> q_values; //an array of int
　  valarray<double> weights; //an array of double
03)使用valarray类构造函数创建对象的例子：
　  double gpa = {3.1,4.2,5.4,3.2,5.6,7.8}; //创建一个double数组
　  valarray<double> v1; //an array of double,size 0
　  valarray<int> v2(8); //an array of int,size 8
　  valarray<int> v3(10,8); //an array of int,size 8,each set to 10
　  valarray<double> v4(gpa,4); //an array of double,size 4,each set to first 4 elements of gpa
　  valarray<int> v5 = {10,9,8,7}; //c++11
04)valarray类方法
　  operator[]() //访问各个元素
　  size(); //返回包含元素数
　  sum(); //返回包含元素和
　  max(); //返回包含元素最大值
　  min(); //返回包含元素最小值
05)在第四章中介绍的vector和array也可以存储数据，但是这些泪提供的算术支持没有valarray多

/*Student类公有继承*/
#ifndef STUDENT_H
#define STUDENT_H

#include <iostream>
#include <string>
#include <valarray>

class Student 
{
private:
    typedef std::valarray<double> ArrayDb;  //给std::valarray<double>起别名为ArrayDb
    
    std::string name;  //name为一个包含对象
    ArrayDb scores;  //scores为一个包含对象
    std::ostream & arr_out(std::ostream & os) const;  //私有方法
public:
    Student() : name("Null Student"),scores() {}  //定义构造函数,并使用成员初始化列表对name和scores进行初始化
    explicit Student(const std::string s) : name(s),scores() {}  //explicit表示关闭隐式转换
    explicit Student(int n) : name("NUll name"),scores(n) {} //set name to Null name and creat array of n elements
    Student(const std::string s,int n) : name(s),scores(n) {}
    Student(const std::string s, const ArrayDb & a) : name(s),scores(a) {} 
    Student(const char* str,const double* pd,int n) : name(s),scores(pd,n) {}
    ~Student() {}  //析构函数
    
    double Average() const;
    const std::string & Name() const;
    double & operator[](int i);  //对[]的重载
    double operator[](int i) const;  //对[]的重载
    
    //friends
    friend std::istream & operator>>(std::istream & is, Student & stu);  //输入一个单词
    friend std::istream & getline(std::istream & is, Student & stu);  //输入一行
    friend std::ostream & operator<<(std::ostream & os,Student & stu);  //输出
    
};

#endif

/*关闭隐式转换的原因*/
/*
Student doh("xiaoming",10);  //使用构造函数Student(const std::string s,int n)创建Stident对象doh
doh = 5;  
//如果没有关键字explict，doh=5 将调用Student(int n) : name("NUll name"),scores(n) {},并使用NUll name来设置name的值
//如果加上explicit则不会进行隐式转换
*/

/*valarray类的介绍*/
/*
01)需包含头文件#include <valarray>
02)使用时，需要在valarray后面加上一对尖括号并在里面写上要使用的数据类型
   valarray<int> q_values;  //an array of int
   valarray<double> weights;  //an array of double
03)使用valarray类构造函数创建对象的例子：
   double gpa = {3.1,4.2,5.4,3.2,5.6,7.8};  //创建一个double数组
   valarray<double> v1;  //an array of double,size 0
   valarray<int> v2(8);  //an array of int,size 8
   valarray<int> v3(10,8);  //an array of int,size 8,each set to 10
   valarray<double> v4(gpa,4);  //an array of double,size 4,each set to first 4 elements of gpa
   valarray<int> v5 = {10,9,8,7};  //c++11
04)valarray类方法
   operator[]()  //访问各个元素
   size();  //返回包含元素数
   sum();  //返回包含元素和
   max();  //返回包含元素最大值
   min();  //返回包含元素最小值
05)在第四章中介绍的vector和array也可以存储数据，但是这些泪提供的算术支持没有valarray多
*/

/*公有继承Student.cpp实现*/
#include "Student.h"

using std::ostream;
using std::istream;
using std::endl;
using std::string;

/*私有方法定义*/
std::ostream & arr_out(std::ostream & os) const
{
    int i;
    int lim = scores.size();
    if(lim>0)
    {
        for(i=0; i<lim; i++)
        {
            os<<scores[i]<<" "
            if(i%5 == 4)  //scores中的四个数据为一行
                os<<endl;
        }
        if(i%5!=0)
            os<<endl;
    }
    else
        os<<"Empty array";
    return os;
}

/*计算分数平均值*/
double Student::Average() const
{
    if(scores.size()>0)
        return scores.sum()/scores.size();  //直接调用valarray类中的方法
    else
        return 0;
}

/*利用类方法访问私有数据*/
const std::string & Student::Name() const
{
    return name;
}

/*对[]的重载*/
double & Student::operator[](int i)
{
    return scores[i];  //同样直接使用valarray类中的方法operator[]()
} 
/*对[]的重载*/
double Student::operator[](int i) const
{
    return scores[i];  //同样直接使用valarray类中的方法operator[]()
}
/*友元函数定义--输入一个单词*/
std::istream & operator>>(std::istream & is, Student & stu)
{
    is>>stu.name;
    return is;
}

/*友元函数定义--输入一行*/
std::istream & getline(std::istream & is, Student & stu)
{
    getline(is,stu.name);
    return is;
}

/*友元函数定义--输出*/
std::ostream & operator<<(std::ostream & os,Student & stu)
{
    os<<"Scores for "<<stu.name<<":
";
    stu.arr_out(os);  //使用私有方法
    return os;
}  

/*user_stu.cpp*/
#include <iostream>
#include "Student.h"

using std::cout;
using std::cin;
using std::endl;

void set(Student &sa,int n);  //在主函数内声明方法
const int pupils = 3;  //定义常数
const int quizzes = 5;

int main()
{
    Student ada[pupils] = {Student(quizzes),Student(quizzes),Student(quizzes)};  //定义Student类矩阵,内包含了三个Student类对象
    int i;
    for(i = 0;i<pupils; i++)
        set(ada[i],quizzes);
    cout<<"
Student List:
";
    for(i=0;i<pupils;i++)
        cout<<ada[i].Name()<<endl;
    cout<<"Results:
";
    for(i=0;i<quizzes;i++)
    {
        cout<<endl<<ada[i];  //这里的<<ada[i]将会首先调用std::ostream & operator<<(std::ostream & os,Student & stu)这个函数,在该函数内继续调用arr_out()函数
        cout<<"average: "<<ada[i].Average()<<endl;
    }
    
    cout<<"Done.
"
    return 0;
}

/*子函数定义*/
void set(Student &sa,int n);
{
    cout<<"Please input the student's name: ";
    getline(cin,sa);
    cout<<"Please input "<<n<<"quiz scires:
";
    for(i=0;i<n;i++)
        cin>>sa[i];  //这里将会调用double & Student::operator[](int i)函数,返回的是scores[i]
    while(cin.get() !='
')
        continue;  //如果没有接收到换行符，那么继续去接收换行符;接收到了换行符则推出此while循环
}

注意：在主函数中，使用了sa[i]，这个是使用了对[]的重载函数，返回的是scores[i]，详见user_main.cpp,刚开始的没看明白

2、包含(公有继承)和私有继承

  

3、is-a关系和has-a关系(复习回顾)

01)is-a关系即派生类对象也是一个基类对象，可以对基类对象执行任何操作；例如有一个Fruit类，保存水果的重量和热量，
　  因为apple是一种水果，所以可以从Fruit类中派生出apple类，apple类将继承Fruit类所有的数据成员(重量和热量)，也可以有属于自己的
　  数据成员，但是属于apple的数据成员不属于Fruit类；公有继承创建is-a关系，它是一种包含关系。
02)has-a关系：例如午餐可能包含水果(Fruit类)，但是午餐并不是水果，所以不能从Fruit类中派生出Lunch类来在午餐中添加水果；在午餐中
　  添加水果的正确方法是创建has-a关系，即午餐中有水果，最容易的方式是，将Fruit对象做为Lunch类的数据成员，即私有继承。

4、私有继承

01)使用私有继承，基类的公有成员和保护成员都将成为派生类的私有成员；这意味着基类方法不会成为派生类的
     对象公有接口的一部分，但是可以在派生类的成员函数中使用它们；
02)包含(公有继承)将对象做为一个命名的成员对象添加到类中，而私有继承将对象做为一个未被命名的继承对象
     添加到类中；
03)声明方法：

class Student : private std::string, private std::valarray
{
public:
      ...
};

(1)其中private可以省略，默认值为private
(2)私有继承不需要私有数据，因为两个基类已经提供了所需的数据成员。
     包含版本(公有继承)提供了两个被显式命名的对象成员，而私有继承提供了两个无名称的自对象成员。

04)公有继承构造函数初始化基类变量方法：

Student(const char *str, const double *pd,int n) : name(str),scores(pd,n) {}  //公有继承构造函数定义方法

私有继承构造函数初始化基类变量方法：

Student(const char *str, const double *pd,int n) : std::string(str),std::valarray<double>(pd,n) {}//私有继承构造函数定义方法

05)公有继承访问基类中的方法(函数)： 

double Student::Average() const
{
    if(scores.size()>0)
    return scores.sum()/scores.size();
    else
    return 0;
} 

私有继承访问基类中的方法(函数)：

double Student::Average() const
{
     if(ArrayDb::size()>0)
      return ArrayDb::sum()/ArrayDb::size();  
    else
          return 0;
}     

注意：typedef std::valarray<double> ArrayDb 

06)访问基类对象方法
     由于string类对象在私有继承中没有名字，此时使用强制转换将Student类转换为string类

const string & Student::Name() const
{
    return (const string &) *this;  //转换结果是继承而来的string对象
} 

上述方法返回一个引用，改引用指向用于调用该方法的Student对象中继承而来的string对象

07)以下是Student.h等代码使用私有继承方法实现

#ifndef STUDENT_H
#define STUDENT_H

#include <iostream>
#include <string>
#include <valarray>

class Student : private std::string,std::valarray
{
private:
    typedef std::valarray<double> ArrayDb;  //名称的替换
    std::ostream & arr_out(std::ostream & os) const;  //声明私有方法
public:
    Student() : std::string("Null name"), ArrayDb() {} //定义构造函数
    explicit Student(const std::string & s) : std::string(s), ArrayDb() {}  ////定义带一个string参数的构造函数
    explicit Student(int n) : std::string("Null name"), ArrayDb(n) {} //explicit表示不可以进行隐式转换 ArrayDb(n)表示创建包含n个double数据的集合
    Student(const std::string & s, int n) : std::string(s),ArrayDb(n) {}
    Student(const char *str,const double *pd,int n) : std::string(str),ArrayDb(pd,n) {}
    ~Student() {}
    
    double Average() const;  //返回ArrayDb中数据的平均值
    double & operator[](int i);  //使用Student类对象访问ArrayDb中的数据
    double operator[](int i) const;  //使用Student类对象访问ArrayDb中的数据
    const std::string & Name() const;  //返回数据std::string（类似返回公有继承中的name）
    
    //friends
    friend std::istream & operator>>(std::istream & is, const Student & s);  //输入一个单词
    friend std::istream & getline(std::istream & is, const Student & s);  //输入一行
    friend std::ostream & operator<<(std::ostream & os, const Student & s);  //输出
}; 

#endif

/*私有继承Student.cpp*/
#include <iostream>
#incldue "Student.h"

using std::istream;
using std::endl;
using std::ostream;
using std::string;

/*
01)返回ArrayDb中数据的平均值
02)私有继承访问基类中的方法
*/
double Student::Average() const
{
    if(std::valarray<double>::size() > 0)  //注意这里的std::valarray<double>也可以换成在h文件中声明的ArrayDb
        return std::valarray<double>::sum() / std::valarray<double>::size();  //由于私有继承是没有变量名字的,所以只能是这样访问基类方法
    else
        return 0;
} 

/*使用Student类对象访问ArrayDb中的数据*/
double & Student::operator[](int i)
{
    return ArrayDb::operator[](i);  //公有继承中实现方法是直接返回scores[i],但是私有继承必须是调用valarray类中的operator[]()方法
} 

/*使用Student类对象访问ArrayDb中的数据*/
double Student::operator[](int i) const
{
    return ArrayDb::operator[](i);
}

/*
01)返回数据std::string（类似返回公有继承中的name）
02)访问基类对象方法:使用强制转换
*/
const std::string & Student::Name() const
{
    return (const std::string &) *this;  //这里是要返回一个string对象，所以要进行强制转换
}

//友元函数定义

/*输入一个单词*/
std::istream & Student::operator>>(std::istream & is, const Student & s)
{
    is>>(string &)s;  //还是要输入一个单词给string对象啊,所以这里还是要进行强制转换
    return is;
}

/*输入一行*/
std::istream & Student::getline(std::istream & is, const Student & s)
{
    getline(is,(string &)s);  //还是要输入一个单词给string对象啊,所以这里还是要进行强制转换
    return is;
}

/*输出*/
std::ostream & Student::operator<<(std::ostream & os, const Student & s)
{
    os<<"Scores for "<<(string &)s<<":
";
    arr_out(os);
    return os;
}

/*定义私有方法*/
std::ostream & Student::arr_out(std::ostream & os) const
{
    int i;
    int lim = ArrayDb::size();
    if(lim != 0)
    {
        for(i=0;i<lim;i++)
        {
            os << ArrayDb::operator[](i);
            if(i%5 == 4)
                os<<endl;  //保证每四个数据输出一个换行
        }
    }
    else
        os << "Empty array"
}

/*私有继承user_main.cpp*/
#include <iostream>
#include "Student.h"

using std::cin;
using std::cout;
using std::endl;

void set(const Student & s,int n);

const int pupils = 3;
const int quizzes = 5;

int main()
{
    int i;
    Student ada[pupils] = {Student(quizzes),Student(quizzes),Student(quizzes)};
    for(i=0;i<pupils;i++)
        set(ada[i],quizzes);
    cout<<"
Student List:
";
    for(i=0;i<pupils;i++)
        cout<<ada[i].Name()<<endl;
    cout<<"Results:
";
    for(i=0;i<quizzes;i++)
    {
        cout<<endl<<ada[i];  //这里的<<ada[i]将会首先调用std::ostream & operator<<(std::ostream & os,Student & stu)这个函数,在该函数内继续调用arr_out()函数
        cout<<"average: "<<ada[i].Average()<<endl;
    }
    
    cout<<"Done.
"
    return 0;
}

void set(const Student & s,int n)
{
    cout << "Please input student name"<<endl;
    getline(cin,s);  //调用对geline()的重载函数
    cout << "Please input " << n << "quize scores" <<endl;
    for(int i=0; i<n; i++)
        cin >> s[i];  //s[i]将调用operator[]()函数
    while(cin.get() != '
')
        continue;
}

 5、使用using重新定义获得访问权限

01)问题的提出：使用保护继承或者是私有继承时，基类的公有方法将成为保护成员或私有成员，假设要让基类的方法在派生类的外面可用
     以下是两种方法：
02)方法一：定义一个使用该基类方法的派生类方法，例如，假设希望Student类能够使用valarray类的sum()方法，可以在Student类中声明
     一个sum()方法，然后像下面这样定义：

double Student::sum() const
{
    return std::valarray<double>::sum();  //使用的是私有继承,所以这里要使用私有继承调用基类方法的方式
}

这样Student对象就可以调用Student::sum()，方法为ada.sum()，假如ada是一个Student对象

03)方法二：使用一个using声明来指出派生类可以使用特定的基类方法，可以在Student.h的公有部分加入如下using声明：

class Student : private std::string, private std::valarray
{
public: 
      using std::valarray<double>::min();
      using std::valarray<double>::max();
        ...
}

假如ada是一个Student对象，那么就可以直接调用min()和max()方法，即ada.min()和ada.max();需要注意的是using声明只适用于私有继承
并不适用于公有继承。

6、多重继承MI

6.1多重继承的引入

本版本重点介绍多重公有继承，其层次结构如下
class Waiter : public Worker {...};
class Singer : public Worker {...};
class SingingWaiter : public Waiter, public Singer {...};
其中Worker是一个基类
注意：本引入涉及到多态

#ifndef WORKER0_H_
#define WORKER0_H_

#include <string>

/*基类*/
class Worker
{
private:
    std::string fullname;
    long id;
public:
    Worker() : fullname("No one"), id(0L) {}  //构造函数定义
    Worker(const std::string & s, long n) : fullname(s),id(n) {}
    ~Worker();
    virtual void Set();  //声明虚方法,在派生类中可不使用virtual,Set()也会自动成为虚方法
    virtual void Show() const;    
}; 
/*派生类Waiter*/
class Waiter : public Worker
{
private:
    int panache;  //在Worker类变量的基础上，添加新的变量
public:
    Waiter() : Worker(),panache(0) {}  //Worker()使用基类名字来初始化基类变量,将调用不带参数的基类构造函数
    Waiter(std::string & s,long n, int p=0) : Worker(s,n),panache(p) {}  //使用带两个参数的基类构造函数初始化基类变量
    Waiter(const Worker &wk, int p=0) : Worker(wk),panache(p) {} //使用基类对象来初始化基类变量
    
    void Set();  //由于在基类中Set()使用的是虚方法,所以在派生类中会自动成为虚方法
    void Show() const;  //同样是自动成为虚方法
};
/*派生类Singer*/
class Singer : public Worker
{
protected:
    enum {other,alto,contralto,soprano,bass,baritone,tenor};  //定义枚举,other=0,alto=1...
    enum {Vtype = 7};
private:
    static char *pv[Vtype]; //声明静态指针数组,并在cpp文件中进行初始化
    int voice;
public:
    Singer() : Worker(), voice(other) {} //使用不带参数的基类构造函数初始化基类变量
    Singer(const std::string & s,long n,int v=other) : Worker(s,n),voice(v) {}
    Singer(const Worker & wk, int v=other) : Worker(wk),voice(v) {}
    
    void Set();  //由于在基类中Set()使用的是虚方法,所以在派生类中会自动成为虚方法
    void Show() const;  //同样是自动成为虚方法    
};

#endif

/*worker0.cpp*/
#include <iostream>
#include "worker0.h"

using std::cin;
using std::cout;
using std::endl;

/*基类Worker中的方法实现*/
Worker::~Worker()
{
    
}

/*基类输入*/
void Worker::Set()
{
    cout << "Enter woker's name: ";
    getline(cin,fullname);
    cout << "Enter worker's ID: ";
    cin >> id;
    while(cin.get() != '
') //一直接收换行符,直到接收到了换行符
        continue;
}

/*基类输出*/
void Worker::Show() const
{
    cout << "Name: " << fullname <<endl;
    cout << "Employee ID: " << id <<endl;
}

/*派生类Waiter类方法实现*/
/*派生类Waiter输入*/
void Waiter::Set()
{
    Worker::Set();  //调用基类中的Set()方法，输入基类中的数据
    cout << "Enter waiter's panche rating: " << endl;
    cin >> panche;
    while(cin.get() != '
') //一直接收换行符,直到接收到了换行符
        continue;
}
/*派生类Waiter输出*/
void Waiter::Show() const
{
    cout<<"Category waiter"<<endl;
    Worker::Show();  //调用基类中的Show()方法
    cout<<"Panache rating: "<<panche<<endl;
}

/*派生类Singer类方法实现*/
char* Singer::pv[] = {other,alto,contralto,soprano,bass,baritone,tenor};//初始化h文件中的pv指针

/*派生类Singer输入*/
void Singer::Set()
{
    Worker::Set();  //调用基类方法
    cout << "Enter number for singer's voice: ";
    int i;
    for(i=0;i<Vtypes;i++)
    {
        cout<<i<<": "<<pv[i]<<"  ";  //由于没有换行符，此处用两个空格隔开两个voice类型
        if(i&4==3)
            cout<<endl;  //每打印四个voice类型输出一个换行符
    }
    if(i%4!=0)
        cout<<endl;
    while(cin>>voice && (voice<0 || voice<=Vtypes))  //检查输入的是否为数字,且该数字是否在0和Vtypes之间
        cout<<"Please enter a value >=0 and <"<<Vtypes<<endl;
    while(cin.get() != '
') //一直接收换行符,直到接收到了换行符
        continue;
}


/*派生类Singer输出*/
void Singer::Show() const
{
    cout<<"Category: singer"<<endl;
    Worker::Show();
    cout<<"Voice range: "<<voice<<endl;
}

/*worktest.cpp*/
#include <iostream>
#include "worker0.h"

const int LIM = 4;
int main()
{
    Waiter bob("Bob Apple",314L,5);  //创建Waiter类对象fullname=Bob Apple，id=314,panache=5;只是初始化，后面输入会覆盖掉这些初始化内容
    Singer bev("Beverlly Hills",522L.3);  //创建Singer对象
    Waiter w_temp;
    Singer s_temp;
    
    Woeker* pw[LIM] = {&bob,&bev,&w_temp,&s_temp}; //创建基类指针，分别指向Waiter对象和Singer对象
    
    int i;
    for(i=0.i<LIm;i++)
        pw[i]->Set();  //
    for(i=0;i<LIM;i++)
    {
        pw[i]->Show(); 
        std::cout<<std::endl;
    }
    return 0;
}
/*
需要注意的是：
01)由于Set()和Show()都是虚方法（在基类中定义的是虚方法，所以在派生类中自动会成为虚方法）,所以
   pw[i]->Set();将根据p[i]指向的对象来确定使用那个版本的Set()函数；例如pw[0]=&bob,而bob是Waiter类对象
   所以pw[0]->Set()将调用Waiter类中的Set()函数;同理pw[1]->Set()将调用Singer类中的Set()方法

*/

注意：

01)worker.h中包括了三个类Worker类(作为基类)、Waiter(派生自Worker类)、Singer类(派生自Worker类)

02)在workerTest.cpp中：由于Set()和Show()都是虚方法（在基类中定义的是虚方法，所以在派生类中自动会成为虚方法）,所以

     pw[i]->Set();将根据p[i]指向的对象来确定使用那个版本的Set()函数；例如pw[0]=&bob,而bob是Waiter类对象
     所以pw[0]->Set()将调用Waiter类中的Set()函数;同理pw[1]->Set()将调用Singer类中的Set()方法

 6.2多重继承的问题与改进

假如有如下继承方式：

class Worker {...}  //作为基类
class Waiter : public Worker {...}  //Waiter类继承自Worker类
class Singer : public Worker {...}  //Singer类继承自Worker

如果定义一个类SingingWaiter类，继承Waiter和Singer，即：

class SingingWaiter : public Waiter, public Singer {...}

此时是有问题的：因为Singer和Waiter都继承了一个Worker，所以SingingWaiter中将含有两个Worker类重复的信息，
在使用多态时候，将会出现如下问题;

SingingWaiter ed;  //声明一个SingingWaiter对象ed
Worker *pw = &ed; //基类指针指向SingingWaiter对象,此时会出现二义性

(2020.06.28晚对于ed会出现二义性的解释，当Worker基类指针pw去调用一个虚函数的时候，那么会根据pw指向的对象去判断调用哪个类中的虚函数，此处基类指针pw指向的是SingingWaiter类对象，所以当pw调用一个虚函数的时候，会调用SingingWaiter类中的虚函数，但是如果SingingWaiter类中不存在这个虚函数，那么pw会去找SingingWaiter最近的一个祖先中去找这个虚函数，此时Waiter和Singer都是SingingWaiter最近的祖先(SingingWaiter同时继承了Waiter和Singer)，且在Waiter类中和Singer类中都有这个虚函数，那么pw会去调用哪个虚函数？此时就出现了二义性)

由于ed中包含两个Worker对象，所以上式会出现二义性，解决方法;

SingingWaiter ed;  //声明一个SingingWaiter对象ed
Worker *pw1 = (Waiter *)&ed; 
Worker *pw2 = (Singer *)&ed;  //使用强制转换

但是这样会使多态复杂化，此时引入虚基类的概念

6.3虚基类

01)使Worker成为Waiter和Singer虚基类的方法:加关键字virtual

class Singer :virtual public Worker {...}
class Waiter :virtual public Worker {...}  //其中virtual和public可以交换次序

然后可以将SingingWaiter定义为：

class SingingWaiter : public Singer, public Waiter {...}

此时SIngingWaiter对象只包含Worker对象的一个副本,继承的Singer和Waiter共享一个Worker对象

02)SingingWaiter构造函数的编写方法(主要是如何填充Worker中的数据)：

     以前的多继承构造函数编写方法：

 class A  //基类
{
    int a;  //省略了关键字private
public:
     A(int n=0) : a(n) {}
         ...
};
class B : public A  //B继承自A
{
    int b;
public:
     B(int m=0,int n=0) : A(n),b(m) {} //使用基类构造函数A()来填充基类数据
         ...
};
class C : public B  //C继承自B
{
    int c;
public:
    C(int q=0,int m=0,int n=0) ： B(m,n), c(q);  //调用B(int m=0,int n=0)构造函数来填充B类和A类中的数据
    ...
};

C类构造函数只能调用B类的构造函数，而B类构造函数只能调用A类构造函数。在C类构造函数中，将m和n的值传递给B类中的
构造函数，而B类中的构造函数又将n值传递给A类的构造函数，最后初始化自己的值c，这样是可行的。

03)但是如果A是虚基类，那么以上传递方法将不会起作用！！即：

SingingWaiter(const Worker &wk, int p=0,int v=Singer::other) : Waiter(wk,p), Singer(wk,v) {} //存在问题的

存在的问题是，自动传递信息时，将通过两种不同的途径(Singer和Waiter)将wk传递给Worker对象。为避免这种冲突，C++在
基类是虚的时候，禁止通过中间类(Singer和Waiter)将基类数据传递给基类。可以采用如下方式：

SingingWaiter(const Worker & wk, int p=0,int v=Singer::other) : Worker(wk),Waiter(wk,p),Singer(wk,v) {}

上述代码显式的调用虚基类构造函数Worker(const Worker &),对于虚基类，这样做是合法的。

那个方法？
01)问题的提出，假如在SingingWaiter中没有重新定义Show()方法，并试图使用SingingWaiter对象调用Show()方法，即：

SingingWaiter newhire("Elise Hawks",2005,6,soprano);
newhire.Show();  //会出现二义性，不知道使用那个祖先中的Show()方法

对于单继承来说，如果没有重新定义Show()，则使用最近祖先中的定义；但是对于多继承来说，则会出现二义性

02)解决方法一：可以使用作用域解析运算符，即：

SingingWaiter newhire("Elise Hawks",2005,6,soprano);
newhire.Singer::Show();  //合法,只有作用域解析运算符来说明要使用Singer类中的Show()f方法

03)解决方法二：最好的方法还是在SingingWaiter中重新定义Show()方法

void SingingWaiter::Show()
{
    Singer::Show();  //但是这种递增方式对SingingWaiter无效，因为它忽略了Wiater类
}

可以使用如下方式进行补救：

void SingingWaiter::Show()
{
    Singer::Show(); //调用了Worker::Show()另外显示自己的私有变量
    Wiater::Show(); //调用了Worker::Show()另外显示自己的私有变量
}

然而这一同样会出现问题：这将显示姓名和ID两次，可以提供只显示Worker类变量方式
和只显示Singer类变量、Waiter类变量的三个方法，最后将他们进行组合，即：

/*在worker类中定义Data()方法*/
void Worker::Data() const
{
   cout << "Name: " << fullname <<endl;
   cout << "ID: " << id << endl;
}
/*在Waiter类中定义Data()方法*/
void Waiter::Data() const
{
   cout << "Panache rating: " << panache <<endl;
}
/*在Singer类中定义Data()方法*/
void Singer::Data() const
{
   cout << "Vocal range: " << pv[voice] <<endl;
}
/*在SingingWaiter类中定义Data()方法*/
void SingingWaiter::Data() const
{
   Singer::Data();
   Waiter::Data();
}
/*在SingingWaiter类中定义Show()方法*/
void SingingWaiter::Show() const
{
   Worker::Data();  //虚基类中的Data()方法
   Data();  //SingingWaiter类中自己定义的Data()方法
}

由于保护成员只可以在本类内和子类内被访问，在其他文件中不可以被访问，所以可以将以上的Data()全部声明为类中的保护成员。

6.4虚基类与二义性

01)使用非虚基类时：如果一个类从不同的类中继承了两个或更多的同名函数(数据或方法)，则使用该
     成员名的时候，如果没有用类名进行限定，将会导致二义性。
02)使用虚基类时：如果一个类从不同的类中继承了两个或更多的同名函数(数据或方法)，则使用该
     成员名的时候，如果没有用类名进行限定，将不一定会导致二义性，如果某个名称优先于其他所有名称
    ，则使用它时，即使不适用限定符，也不会导致二义性。
03)一个成员名如何优先于另一个成员们呢？派生类中的名称优先于直接或间接祖先类中相同名称，例如：

class B    //作为基类
{
public:
    short q();
    ...
};
class C : virtual public B  /使B成为虚基类
{
public:
    long q();  //由于C继承B,所以C中的q()优先于B中的q()
    int omg();
};
class D : public C
{
   ...
};
class E :virtual public B
{
private:
   int omg();
   ...
};
class F : public D, public E
{
   q();  //这里使用的是C中的q()方法;因为只有B和C中有q()方法,而C中的优先于B中的q()方法
         //而D继承自C，C继承自B
   omg();  //由于C中有omg()方法，E中也有;但是C不是E的基类,且E也不是C的基类,所以C和E中的omg()方法无法比较有限性
           //这里调用omg()将会导致二义性
   ...
};

 7、类模板

7.1类模板简单实现

01)由于模板不是函数,它们不可单独编译，因此模板必须和实例化(即实现)一起使用,为此最简单的方法就是将所有模板信息放入一个头文件中
02)模板的具体实现成为实例化或具体化，即将int、string、double等替换Type
03)每个函数定义都需要使用项目的模板声明template <class Type> 打头
04)类限定符Stack::改为Stack<Type>::
05)如果在类声明中定义了方法(内联定义)，则可以省略模板前缀和类限定符。

由于[]的优先级比--高,所以在执行item = items[--top]的时候,先将items[top]的值赋给item，后将top的值自减1

类声明+类方法定义的h文件：

#ifndef STACKTP_H_
#define STACKTP_H_

/*
01)下面的type只说明Type是一个通用类型说明符,并不是类,在使用时将用实际类型替换它
02)Type被称为泛型标识符
*/
template <class Type>  //关键字template告诉编译器将要创建一个模板，其中class可用typename替换 Tyoe为任意取的名字,实际会被int、string等代替
class Stack
{
private:
    enum {MAX = 10};  //使用枚举创建常量
    Type items[MAX];  //使用模板中的Type创建数组
    int top;
public:
    Stack();  //声明构造函数
    bool isempty();
    bool isfull();
    bool push(const Type & item); //入栈
    bool pop(Type & item);  //出栈，由于是使用的引用,故在item的变化和传入的实参一起变化(即形参和实参一起变化)
};

/*
01)由于模板不是函数,它们不可单独编译，因此模板必须和实例化(即实现)一起使用,为此最简单的方法就是将所有模板信息放入一个头文件中
02)模板的具体实现成为实例化或具体化，即将int、string、double等替换Type
03)每个函数定义都需要使用项目的模板声明template <class Type> 打头
04)类限定符Stack::改为Stack<Type>::
05)如果在类声明中定义了方法(内联定义)，则可以省略模板前缀和类限定符。
*/
template <class Type>   //模板前缀
Stack<Type>::Stack()
{
    top = 0;
}

/*判断栈是否为空*/
template <class Type>   
bool Stack<Type>::isempty()
{
    return top == 0; //若top=0则返回true
}

/*判断栈是否已满*/
template <class Type>
bool Stack<Type>::isfull()
{
    return top == MAX; //若top=MAX则返回true
}

/*入栈*/
template <class Type>
bool Stack<Type>::push(const Type & item)
{
    if (top < MAX)
    {
        items[top++] = item;  //将传入的参数传入items数组(栈),并将top自加1
        return true;
    }
    else
        return false;
}

/*
01)出栈
02)由于[]的优先级比--高,所以在执行item = items[--top]的时候,先将items[top]的值赋给item，后将top的值自减1
02)由于--top是先修改后使用,故pop(po)中
*/
template <class Type>
bool Stack<Type>::pop(Type & item)
{
    if (top > 0)
    {
        item = items[--top];  //将数组items(栈)中的参数传给item,同时主函数中的实参也会更新
        return true;
    }
    else
        return false;
}

#endif

使用类模板：

#include <iostream>
#include <string>
#include <cctype>
#include "stacktp.h"

using std::string;
using std::cin;
using std::cout;
using std::endl;

/*
01)模板类对象的创建方法：
   Stack<int> st1;  //使用int替换模板中所有的Type
   Stack<string> st2;
*/
int main()
{
    Stack<string> st;  //将Stack类中的Type使用string替换,并创建Stack对象st,st为模板类对象
    char ch;
    string po;
    cout << "please enter A to add a purchase order,
"
        << "P to process a puurchase order, or Q to quit." << endl;
    while (cin >> ch && std::toupper(ch) != 'Q')  //注:toupper(ch)将ch字符转换为大写
    {
        while (cin.get() != '
')
            continue;  //一直接收换行符
        if (!std::isalpha(ch))  //isalpha(ch)判断ch是否为英文字母,若是则返回非0
        {
            cout << 'a';  //发出蜂鸣声
            continue;  //返回while循环
        }
        switch (ch)
        {
        case 'A':
        case 'a':
            cout << "Enter a purchase order to add: ";
            cin >> po;
            if (st.isfull())
                cout << "栈已满!" << endl;
            else
                st.push(po);  //将po入栈
            break;
        case 'p':
        case 'P':
            if (st.isempty())
                cout << "栈已空!" << endl;
            else
            {
                st.pop(po);  //将po出栈,并更新po；因为po为被指向的引用，会随着形参的改变而改变
                cout << "purchase order #" << po << " popped" << endl;
                break;
            }
        }
        cout << "please enter A to add a purchase order,
"
            << "P to process a puurchase order, or Q to quit." << endl;
    }
    cout << "Bye!" << endl;
    system("pause");
    return 0;
}

执行结果：

 7.2栈指针

需要参考int**表示一个二维数组方法：https://www.cnblogs.com/YiYA-blog/p/11456085.html

另外此程序也展示了类对象可以直接用直接访问运算符(点)来访问自己的私有数据

栈中存储的是指针(字符串的首地址)

#ifndef STACKTP1_H_
#define STACKTP1_H_

template <class Type>
class Stack
{
private:
    enum {SIZE = 10};  //默认栈大小
    int stacksize;
    Type * items;  //栈  Type用char*替换后,即char** items;创建指向指针的指针,但是一旦用new给items分配空间之后,就items就可以指代一个二维数组
    int top;
public:
    explicit Stack(int ss = SIZE);  //构造函数,因为该构造函数只含有一个参数,需要使用explicit关闭隐式转换
    Stack(const Stack & st);  //声明复制构造函数
    ~Stack() { delete[] items; }  //由于是要将Type声明为char *，所以需要加上[]
    bool isempty() { return top == 0; }
    bool isfull() { return top == stacksize; }
    bool push(const Type & item);
    bool pop(Type & item);
    Stack & operator=(const Stack & st);
};

/*含有一个int型参数的构造函数*/
template <class Type>
Stack<Type>::Stack(int ss) : stacksize(ss), top(0)
{
    items = new Type[stacksize];  //给items分配空间,当Type=char*时,items = new char*[stacksize]即创建一个数组,数组内全是指针
}

/*
01)含有一个Stack类对象引用参数的构造函数
02)items = new Type[stacksize];给items分配空间,当Type=char*时,items = new char*[stacksize]即创建一个数组,数组内全是指针
*/
template <class Type>
Stack<Type>::Stack(const Stack & st)
{
    stacksize = st.stacksize;  //使用类对象直接访问自己本身的私有数据
    top = st.top;  //使用类对象直接访问自己本身的私有数据
    items = new Type[stacksize]; //Type用char*替换后,即items = new char*[stacksize]创建一个数组,内全为指针
    for (int i = 0; i < top; i++)
    {
        items[i] = st.items[i];
    }
}

/*入栈*/
template <class Type>
bool Stack<Type>::push(const Type & item)
{
    if (top < stacksize)
    {
        items[top++] = item;
        return true;
    }
    else
        return false;
}

/*出栈*/
template <class Type>
bool Stack<Type>::pop(Type & item)
{
    if (top > 0)
    {
        item = items[--top];
        return true;
    }
    else
        return false;
}

/*
01)对=的重载函数定义
02)注意：函数返回类型为Stack类引用时,返回类型在声明中可以直接写Stack & ,但是在定义中必须使用Stack<Type> &
03)返回类型为类引用，如果在类中可以使用Stack,但是在类外必须使用Stack<Type>
04)一下代码使用了深复制
*/
template <class Type>
Stack<Type> & Stack<Type>::operator=(const Stack & st)
{
    if (this == &st)
        return *this;
    delete[] items;
    stacksize = st.stacksize;
    top = st.top;
    items = new Type[stacksize];
    for (int i = 0; i < top; i++)
        items[i] = st.items[i];
    return *this;
}

#endif

#include <iostream>
#include <cstdlib>
#include <ctime>
#include "stacktp1.h"

using std::cin;
using std::cout;
using std::endl;
const int Num = 10;

int main()
{
    std::srand(std::time(0));
    cout << "please enter atck size: ";
    int stacksize;
    cin >> stacksize;

    Stack<const char*> st(stacksize); //隐式的调用含一个int行参数的Stack类构造函数创建对象st,其中h文件中所有Type用char*代替

    //创建指针数组
    const char* in[Num] = {
        "1: Hank Gilgaeh", "2: Kiki Ishtar",
        "3: Wolfang Kibble", "4: Ian Flagranti",
        "5: Betty Rocker", "6: Ports Koop",
        "7: Joy Almondo", "8: Xavertie Paprika",
        "9: Juan Moora", "10: Misha Mache"
    };
    const char* out[Num];  //编译打印输出

    int processed = 0;
    int nextin = 0;
    while (processed < Num)
    {
        if (st.isempty())              //栈只有第一次执行的时候是空的,之后就是有内容在里面，不是空也不是满的状态
            st.push(in[nextin++]);    //以指针的形式入栈，即栈中存储的是一个字符串的地址
        else if (st.isfull())        //当达到主程序中输入的stacksize之后,栈就达到了满的状态,然后执行第一个else if,之后就有达到了不满要也不空的状态
            st.pop(out[processed++]); 
        else if (std::rand() % 2 && nextin < Num)  //执行下面两句的几率各为50%
            st.push(in[nextin++]);  
        else
            st.pop(out[processed++]);
    }
    for (int i = 0; i < Num; i++)
        cout << out[i] << endl;
    system("pause");
    return 0;

}

执行结果：