直奔主题。
假设有这样的一个需求,要给Animal类添加一个方法,如果一种动物可以吃掉另一种动物,则返回true,否则返回false。
接口可能会是下面这样:
struct Animal {
virtual bool eat(const Animal& animal) const = 0;
};
那怎么实现呢?肯定是多态,估计你能想到的第一种方法就是这样:
基类Animal的每个派生类都实现eat方法,然后根据参数运行时类型返回适当的值。
如何获取参数类型呢?需要使用typeid。
代码如下:
bool Dog::eat(const Animal& animal) const {
if (typeid(animal) == typeid(Cat)) {
return true;
} else if (typeid(animal) == typeid(Lion)) {
return false;
}
return false;
}
bool Lion::eat(const Animal& animal) const { return true; }
bool Cat::eat(const Animal& animal) const { return false; }
这种方法可以满足需求,但也只适用于类的数量比较少的情况。如果类的数量太多,每个重写的方法实现体里面都会有特别多的if-else。关于if-else的弊端我之前介绍过,可以看看这里:《少写点if-else吧,它的效率有多低你知道吗?》
这里还有些其他的问题:
-
随着类数量的增加,这种代码会变得很乱,不容易维护。
-
如果添加了新类型,这种方式不会强制要求派生类考虑新类型,假如新添加了Bear类,如果在某一个派生类里忘记处理Bear类,结果就可能有误。
-
typeid这种东西很鸡肋,就不像个纯粹的面向对象结构。
那是不是可以这样做?
struct Animal {
virtual bool eat(const Dog&) const = 0;
virtual bool eat(const Cat&) const = 0;
virtual bool eat(const Lion&) const = 0;
};
然后每个派生类重写相应的方法,这种方法貌似可行,但是只有单方向多态,真正使用起来会有些不方便。而此方法的使用一定要这样:
animal.eat(cat);
animal.eat(dog);
animal.eat(lion);
真正的双方向多态使用方式应该是这样:
animal1.eat(animal2);
上面的方法还是不满足需求。
可以考虑这种方式:
struct Dog;
struct Cat;
struct Lion;
struct Animal {
virtual bool eat(const Animal&) const = 0;
virtual bool eatenBy(const Dog&) const = 0;
virtual bool eatenBy(const Cat&) const = 0;
virtual bool eatenBy(const Lion&) const = 0;
};
struct Dog : public Animal {
bool eat(const Animal& animal) const override { return animal.eatenBy(*this); }
bool eatenBy(const Dog&) const override { return false; }
bool eatenBy(const Cat&) const override { return false; }
bool eatenBy(const Lion&) const override { return true; }
};
使用方式如下:
animal1.eat(animal2);
OK,满足需求。
这里有几个关键点:
-
基类那里需要使用前置声明,因为基类需要使用派生类的引用。
-
这里产生了两次多态,一次是运行时多态,另一次是编译时多态。
-
代码逻辑清晰,没有那么多if-else,扩展方便。
这种模式叫双分派设计模式,关键在于基于参数上的方法调用来确定结果。
打完收工。