分享一个编程设计小技巧

直奔主题。

假设有这样的一个需求，要给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吧，它的效率有多低你知道吗？》

这里还有些其他的问题：

1. 随着类数量的增加，这种代码会变得很乱，不容易维护。

2. 如果添加了新类型，这种方式不会强制要求派生类考虑新类型，假如新添加了Bear类，如果在某一个派生类里忘记处理Bear类，结果就可能有误。

3. 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，扩展方便。

这种模式叫双分派设计模式，关键在于基于参数上的方法调用来确定结果。

打完收工。