问题
C++ 是否允许一个类继承自多个父类?
C++ 支持编写多重继承的代码
一个子类可以拥有多个父类
子类拥有所有父类的成员变量
子类继承所有父类的成员函数
子类对象可以当作任意父类对象使用
多重继承的语法规则
多重继承的本质与单继承相同!
多重继承问题一
#include <iostream>
#include <string>
using namespace std;
class BaseA
{
int ma;
public:
BaseA(int a)
{
ma = a;
}
int getA()
{
return ma;
}
};
class BaseB
{
int mb;
public:
BaseB(int b)
{
mb = b;
}
int getB()
{
return mb;
}
};
class Derived : public BaseA, public BaseB
{
int mc;
public:
Derived(int a, int b, int c) : BaseA(a), BaseB(b)
{
mc = c;
}
int getC()
{
return mc;
}
void print()
{
cout << "ma = " << getA() << ", "
<< "mb = " << getB() << ", "
<< "mc = " << mc << endl;
}
};
int main()
{
cout << "sizeof(Derived) = " << sizeof(Derived) << endl; // 12
Derived d(1, 2, 3);
d.print();
cout << "d.getA() = " << d.getA() << endl;
cout << "d.getB() = " << d.getB() << endl;
cout << "d.getC() = " << d.getC() << endl;
cout << endl;
BaseA* pa = &d;
BaseB* pb = &d;
cout << "pa->getA() = " << pa->getA() << endl;
cout << "pb->getB() = " << pb->getB() << endl;
cout << endl;
void* paa = pa;
void* pbb = pb;
if( paa == pbb )
{
cout << "Pointer to the same object!" << endl;
}
else
{
cout << "Error" << endl;
}
cout << "pa = " << pa << endl;
cout << "pb = " << pb << endl;
cout << "paa = " << paa << endl;
cout << "pbb = " << pbb << endl;
return 0;
}
Derived 类多重继承自 BaseA 类 和 BaseB 类,拥有 BaseA 类 和 BaseB 类的所有成员变量和成员函数
第 68 行和第 69 行,根据赋值兼容性原则,子类指针可以指向父类对象,
第 80 行,通过打印查看 paa 和 pbb 指向的地址是否相同
程序运行结果如下图所示:
通过打印可以看出 paa 和 pbb 指向的地址并不相同,但它们确实指向的是同一个对象,这就是多重继承的其中一个问题
通过多重继承得到的对象可能拥有 "不同的地址" !!!
解决方案:无
多重继承可能产生冗余的成员
当多重继承关系出现闭合时将产生数据冗余的问题!!!
多重继承问题二
#include <iostream>
#include <string>
using namespace std;
class People
{
string m_name;
int m_age;
public:
People(string name, int age)
{
m_name = name;
m_age = age;
}
void print()
{
cout << "Name = " << m_name << ", "
<< "Age = " << m_age << endl;
}
};
class Teacher : public People
{
public:
Teacher(string name, int age) : People(name, age)
{
}
};
class Student : public People
{
public:
Student(string name, int age) : People(name, age)
{
}
};
class Doctor : public Teacher, public Student
{
public:
Doctor(string name, int age) : Teacher(name, age), Student(name + "1", age + 1)
{
}
};
int main()
{
Doctor d("Delphi", 33);
d.Teacher::print();
d.Student::print();
return 0;
}
Teacher 类和 Studnet 类都继承自 People 类;Doctor 类多继承自 Teacher 类和 Studnet 类,那么 Doctor 类是否会存在 People 类中重复的成员变量和成员函数呢?
第 51 行和第 52 行,必须指定 print() 函数的作用域,否则会编译出错,这说明了 Doctor 类拥有两个不同作用域的 print() 函数
程序运行结果如下图所示:
通过打印可以看出,两个 print() 函数打印出来的 Name 和 Age 都不同,说明 Doctor 类拥有 People 类中重复的成员变量
解决方案:虚继承
虚继承能够解决数据冗余问题
中间层父类不再关心顶层父类的初始化
最终子类必须直接调用顶层父类的构造函数
虚继承初探
#include <iostream>
#include <string>
using namespace std;
class People
{
string m_name;
int m_age;
public:
People(string name, int age)
{
m_name = name;
m_age = age;
}
void print()
{
cout << "Name = " << m_name << ", "
<< "Age = " << m_age << endl;
}
};
class Teacher : virtual public People
{
public:
Teacher(string name, int age) : People(name, age)
{
}
};
class Student : virtual public People
{
public:
Student(string name, int age) : People(name, age)
{
}
};
class Doctor : public Teacher, public Student
{
public:
Doctor(string name, int age) : Teacher(name, age), Student(name, age), People(name, age)
{
}
};
int main()
{
Doctor d("Delphi", 33);
d.print();
return 0;
}
Teacher 类和 Studnet 类都虚继承继承自 People 类,在 Doctor 类的构造函数中手动调用顶层父类 People 类的构造函数,这样 Doctor 类中就没有冗余的成员变量和成员函数
第 51 行,我们可以不用指定作用域,直接调用 print(),这证明了虚继承解决了数据冗余的问题
程序运行结果如下图所示:
问题:
当架构设计中需要继承时,无法确定使用直接继承还是虚继承!!
多重继承可能产生多个虚函数表
多重继承问题三
#include <iostream>
#include <string>
using namespace std;
class BaseA
{
public:
virtual void funcA()
{
cout << "BaseA::funcA()" << endl;
}
};
class BaseB
{
public:
virtual void funcB()
{
cout << "BaseB::funcB()" << endl;
}
};
class Derived : public BaseA, public BaseB
{
};
int main()
{
Derived d;
BaseA* pa = &d;
BaseB* pb = &d;
BaseB* pbe = (BaseB*)pa; // oops!!
BaseB* pbc = dynamic_cast<BaseB*>(pa);
cout << "sizeof(d) = " << sizeof(d) << endl;
cout << "Using pa to call funcA()..." << endl;
pa->funcA();
cout << "Using pb to call funcB()..." << endl;
pb->funcB();
cout << "Using pbc to call funcB()..." << endl;
pbc->funcB();
cout << endl;
cout << "pa = " << pa << endl;
cout << "pb = " << pb << endl;
cout << "pbe = " << pbe << endl;
cout << "pbc = " << pbc << endl;
return 0;
}
第 34 行,用 C 语言中强制类型转换的方式将 pa 强转为 BaseB* 类型,这样是有问题的,这样 pbe 实际指向的不是 Derived 中的 BaseB 部分,而是 Derived 中的 BaseA 部分
第 35 行,用 dynamic_cast 的方式将 pa 强转为 BaseB* 类型,这种强转的方式是安全的,会根据实际指向的对象类型来进行强转
程序运行结果如下图所示:
d 的所占用的内存大小是16,是因为 BaseA 和 BaseB 都有虚函数,Derived 类继承了 BaseA 和 BaseB 的虚函数表指针
需要进行强制类型转换时,C++ 中推荐使用新式类型转换关键字!!
解决方案:dynamic_cast
工程开发中的 "多重继承" 方式:
单继承某个类 + 实现 (多个) 接口
正确的多继承方式
#include <iostream>
#include <string>
using namespace std;
class Base
{
protected:
int mi;
public:
Base(int i)
{
mi = i;
}
int getI()
{
return mi;
}
bool equal(Base* obj)
{
return (this == obj);
}
};
class Interface1
{
public:
virtual void add(int i) = 0;
virtual void minus(int i) = 0;
};
class Interface2
{
public:
virtual void multiply(int i) = 0;
virtual void divide(int i) = 0;
};
class Derived : public Base, public Interface1, public Interface2
{
public:
Derived(int i) : Base(i)
{
}
void add(int i)
{
mi += i;
}
void minus(int i)
{
mi -= i;
}
void multiply(int i)
{
mi *= i;
}
void divide(int i)
{
if( i != 0 )
{
mi /= i;
}
}
};
int main()
{
Derived d(100);
Derived* p = &d;
Interface1* pInt1 = &d;
Interface2* pInt2 = &d;
cout << "p->getI() = " << p->getI() << endl; // 100
pInt1->add(10);
pInt2->divide(11);
pInt1->minus(5);
pInt2->multiply(8);
cout << "p->getI() = " << p->getI() << endl; // 40
cout << endl;
cout << "pInt1 == p : " << p->equal(dynamic_cast<Base*>(pInt1)) << endl;
cout << "pInt2 == p : " << p->equal(dynamic_cast<Base*>(pInt2)) << endl;
return 0;
}
Derived 类多继承自 Base 类和两个接口
程序运行结果如下图所示:
pInt1 和 pInt2 实际指向的是 Derived 类对象,所以 84 行和 85 行的 dynamic_cast 强转为 Base 类可以成功
一些有用的工程建议
先继承一个父类,然后实现多个接口
父类中提供 equal() 成员函数
equal() 成员函数用于判断指针是否指向当前对象
与多重继承相关的强制类型转换用 dynamic_cast 完成
小结
C++ 支持多重继承的编码方式
多重继承容易带来问题
- 可能出现 "同一个对象的地址不同" 的情况
- 虚继承可以解决数据冗余的问题
- 虚继承使得架构设计可能出现问题
多继承中可以出现多个虚函数表指针
与多继承相关的强制类型转换用 dynamic_cast 完成
工程开发中采用 "单继承多接口" 的方式使用多继承
父类提供成员函数用于判断指针是否指向当前对象