虚拟继承

virinherit.hpp

 

class testvirbase
{
private:
    int m_base_data;
public:
    testvirbase(int data);
    virtual ~testvirbase();
    void print() const;
};

class virtest1 : virtual public testvirbase
{
private:
    int m_virtest1_data;
public:
    virtest1(int basedata, int data);
    virtest1(int data);
    virtual ~virtest1();
    void print() const;
};

class virtest2 : virtual public testvirbase
{
private:
    int m_virtest2_data;
public:
    virtest2(int basedata, int data);
    virtest2(int data);
    virtual ~virtest2();
    void print() const;
};

class virtest3 : public virtest1, public virtest2
{
private:
    int m_virtest3_data;
public:
    virtest3(int base_data, int virtest1_data, int virtest2_data, int data);
    virtest3(int base_data1, int virtest1_data, int base_data2, int virtest2_data, int data);
    virtual ~virtest3();
    void print() const;
};

 

virinherit.cpp

 

#include
using namespace std;

#include "virinherit.hpp"

testvirbase::testvirbase(int data)
{
    m_base_data = data;
    cout<<"construct class testvirbase"<}

testvirbase::~testvirbase()
{
    cout<<"destruct class testvirbase"<}

void testvirbase::print() const
{
    cout<<"class testvirbase data:\t"<}

virtest1::virtest1(int basedata, int data):testvirbase(basedata)
{
    m_virtest1_data = data;
    cout<<"construct class virtest1"<}

virtest1::virtest1(int data) : testvirbase(1)
{
    m_virtest1_data = data;
    cout<<"construct class virtest1"<}

virtest1::~virtest1()
{
    cout<<"desturct class virtest1"<}

void virtest1::print() const
{
    testvirbase::print();
    cout<<"class virtest1 data:\t"<}

virtest2::virtest2(int basedata, int data):testvirbase(basedata)
{
    m_virtest2_data = data;
    cout<<"construct class virtest2"<}

virtest2::virtest2(int data) : testvirbase(2)
{
    m_virtest2_data = data;
    cout<<"construct class virtest2"<}

virtest2::~virtest2()
{
    cout<<"desturct class virtest2"<}

void virtest2::print() const
{
    testvirbase::print();
    cout<<"class virtest2 data:\t"<}

virtest3::virtest3(int base_data, int virtest1_data, int virtest2_data, int data)
        : virtest1(virtest1_data), virtest2(virtest2_data), testvirbase(base_data)
{
    m_virtest3_data = data;
    cout<<"construct class virtest3"<}

virtest3::virtest3(int base_data1, int virtest1_data, int base_data2, int virtest2_data, int data)
        : virtest1(base_data1, virtest1_data), virtest2(base_data2, virtest2_data), testvirbase(base_data1)
{
    m_virtest3_data = data;
    cout<<"construct class virtest3"<}

virtest3::~virtest3()
{
    cout<<"destruct class virtest3"<}

void virtest3::print() const
{
    virtest1::print();
    virtest2::print();
    cout<<"class virtest3 data:\t"<}

 

int main()
{
    virtest3 *pdata = new virtest3(1, 2, 3, 4, 5);
    virtest2 *pvirtest2data = pdata;
    virtest1 *pvirtest1data = pdata;
    testvirbase *pbasedata = NULL;

 

    cout<<"class virtest3"<    pdata->print();

    cout<<"class virtest2"<    pvirtest2data->print();

    cout<<"class virtest1"<    pvirtest1data->print();

 

    cout<<"class testvirbase from virtest2"<    pbasedata = pvirtest2data;
    pbasedata->print();

 

    cout<<"class testvirbase from virtest1"<    pbasedata = pvirtest1data;
    pbasedata->print();

 

    //使用虚拟继承后，base类只构造了一次，但是会影响性能，因为最终类的对象对base类的引用是间接引用的

    cout<

    pbasedata = pdata;
    pbasedata->print();

    delete pdata;
    return 0;
}

 

 

输出结果：

construct class testvirbase
construct class virtest1
construct class virtest2
construct class virtest3
class virtest3

class testvirbase data: 1
class virtest1 data:    2
class testvirbase data: 1
class virtest2 data:    4
class virtest3 data:    5
class virtest2

class testvirbase data: 1
class virtest2 data:    4
class virtest1

class testvirbase data: 1
class virtest1 data:    2
class testvirbase from virtest2

class testvirbase data: 1
class testvirbase from virtest1

class testvirbase data: 1

class testvirbase data: 1
destruct class virtest3
desturct class virtest2
desturct class virtest1
destruct class testvirbase

阅读(1124) | 评论(0) | 转发(0) |

0

上一篇：C++多继承

下一篇：陀螺