其他
分享一个编程设计小技巧（没有两三年工作经验估计看不懂）
直奔主题。
假设有这样的一个需求，要给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，扩展方便。
这种模式叫双分派设计模式，关键在于基于参数上的方法调用来确定结果。
打完收工。
往期推荐