第19课 - 专题三经典问题解析
1. 当多态遇见对象数组会发生什么？
#include <cstdlib>
#include <iostream>
using namespace std;
class Parent
{
protected:
int i;
public:
virtual void f()
{
cout<<"Parent::f"<<endl;
}
};
//sizeof(Parent) = 8，int i占四个字节，虚函数占四个字节。
class Child : public Parent
{
protected:
int j;
public:
Child(int i, int j)
{
this->i = i;
this->j = j;
}
void f()
{
cout<<"i = "<<i<<" "<<"j = "<<j<<endl;
}
};
//sizeof(child) = 12，继承来int i四个字节，自己又定义四个字节，虚函数表四个字节
int main(int argc, char *argv[])
{
Parent* p = NULL;
Child* c = NULL;
Child ca[3] = {Child(1, 2), Child(3, 4), Child(5, 6)};
p = ca; //赋值兼容性原理 ，数组名就是第一个元素的地址 i=1,j=2
c = ca; //i=1,j=2
cout<<hex<<p+1<<endl;
p->f(); //f是个重写函数 ,发生了多态，要根据实际的情况来判定用的那个函数。
//这行有误
c->f();
p++; //指向数组中的第二个对象
c++;
// p->f();
// c->f();
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
不要将多态应用于数组。指针运算是通过指针的类型进行的。多态通过虚函数表实现的。
指针运算是编译器根据指针的类型来进行的，多态是在运行的时候通过虚函数表查询来进行的。这两种实现方式是不同的。多态是程序运行的时候动态的查找函数的。
l 多态与指针的混搭的结果
我们看ca[0]的长度是12，只有12个字节长度的指针才能与它合理搭配。
结论：
不要在数组上使用多态。
2. 为什么没有讲解多重继承
C++在语法上是支持多重继承的。
l 被实际开发经验抛弃的多继承
工程开发中真正意义上的多继承是几乎不被使用的。
多重继承带来的代码复杂性远多于其带来的便利。
多重继承对代码的维护性上的影响是灾难性的。
再设计方法上，任何多继承都可以用单继承来代替。
3. 多继承复杂性示例
#include <cstdlib>
#include <iostream>
using namespace std;
class Object
{
protected:
int d;
public:
void f()
{
cout<<"Object::f"<<endl;
}
};
class P1 : public Object
{
protected:
int i;
};
class P2 : public Object
{
protected:
int j;
};
class Child : public P1, public P2
{
public:
Child(int i, int j)
{
this->d = 0; //二义性 ，child不是直接继承的object，而是间接的，有了两个d
this->i = i;
this->j = j;
}
void print()
{
cout<<"i = "<<i<<" "<<"j = "<<j<<endl;
}
};
int main(int argc, char *argv[])
{
Child c(1, 2);
c.print();
c.f(); //同样有二义性，不知道是从哪里来的，继承只能感受到，直接的父类。
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
在只有单继承的系统中，类之间的继承关系为一棵树。
在引入多重继承的系统中，类之间的继承关系呈现为一张图。
l C++中对多继承二义性的解决方案
虚继承：
为了解决从不同途径继承来的同名数据成员造成的二义性问题，可以将共同的基类设置为虚基类。这是从不同的路径继承过来的同名数据成员在内存中就有一个拷贝。
这样做，实际上是治标不治本，只会使得在工程中更加麻烦。
class P1 : virtual public Object
{
protected:
int i;
};
class P2 : virtual public Object
{
protected:
int j;
};
在实际的工程中的类是成百上千的，所以我们实际工作中尽量少使用多继承。虚函数是很占用空间的，不写又会怀疑。
4. C++是否有Java中接口的概念
绝大多数面向对象的语言都不支持多继承。
绝大多数面向对象语言都支持接口的概念。
C++中没有接口的概念。
C++中可以使用虚函数来实现接口
class Interface
{
public:
virtual void func1() = 0;
virtual void func2(int i) = 0;
virtual void func3(int i, int j) = 0;
};
实际的工程经验证明。多重继承接口不会带来二义性和复杂性等问题。多重继承可以通过精心设计用单继承和接口来代替。
接口只是一个功能说明，而不是功能实现。子类需要根据功能说明定义功能实现。
#include <cstdlib>
#include <iostream>
using namespace std;
class Interface1 //第一个接口
{
public:
virtual void print() = 0;
virtual int add(int i, int j) = 0;
};
struct Interface2 //第二个接口
{
virtual int add(int i, int j) = 0;
virtual int minus(int i, int j) = 0;
};
class Child : public Interface1, public Interface2
{
public:
void print()
{
cout<<"Child::print"<<endl;
}
int add(int i, int j)
{
return i + j;
}
int minus(int i, int j)
{
return i - j;
}
};
int main(int argc, char *argv[])
{
Child c;
c.print();
cout<<c.add(3, 5)<<endl;
cout<<c.minus(4, 6)<<endl;
Interface1* i1 = &c;
Interface2* i2 = &c;
cout<<i1->add(7, 8)<<endl;
cout<<i2->add(7, 8)<<endl;
cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}
运行结果：
Child::print
8
-2
15
15
专题三中的多态是实现设计模式的基本技术！