Question

我指的是文章Implementing a Subject/Observer pattern with templates

我做了一些修改，它变成了如下代码。

template <class T, class A>
class Observer {
public:
    Observer() {}
    virtual ~Observer() {}
    virtual void update(T& subject, A arg) = 0;
};

template <class T, class A>
class Subject
{
public:
    Subject() {}
    virtual ~Subject() {}

    // Take note that, we didn't make the following functions as virtual,
    // as we do not expect them to be overridden.
    void attach(Observer<T, A> &observer) {
        // Ensure no duplication.
        std::vector<Observer<T, A> *>::const_iterator iterator = std::find(observers.begin(), observers.end(), &observer);
        if (iterator == observers.end()) {
            observers.push_back(&observer);
        }
    }

    void dettach(Observer<T, A> &observer) {
        std::vector<Observer<T, A> *>::const_iterator iterator = std::find(observers.begin(), observers.end(), &observer);
        if (iterator != observers.end()) {
            observers.erase(iterator);
        }
    }

    void dettachAll() {
        observers.clear();
    }

    void notify(A arg)
    {
        std::vector<Observer<T, A> *>::const_iterator it;
        for (it = observers.begin(); it != observers.end(); it++) { 
            (*it)->update(*(static_cast<T *>(this)), arg);
        }
    }

private:
    std::vector<Observer<T, A> *> observers;
};

后来，我意识到(*it)->update(*(static_cast<T *>(this)), arg);有限制。例如，

// cause compilation error in static_cast, as it cannot cast cat1 to animal.
class cat1 : public animal, public Subject<animal, int> {
public:
    virtual void speak() {
        notify(888);
    }
};

class zoo1 : public Observer<animal, int> {
public:
    zoo1() {
        c.attach(*this);
        c.speak();
    }

    virtual void update(animal& subject, int arg) {
        cout << "zoo1 received notification " << arg << endl;
    }

    cat1 c;
};

我可以将static_cast更改为dynamic_cast来解决问题。 但是，我不确定是否会陷入其他陷阱？我对作者static_cast初衷的猜测是确保在编译期间进行类型安全检查。

Answer 1

你的问题来自于动物应该不仅是猫的主题，

class animal : public Subject<animal,int>
{
    ...
};

class cat1 : public animal
{
    public:
    virtual void speak() 
    {
        notify(888);
    }
};

class zoo1 : public Observer<animal, int> {
public:
    zoo1() 
    {
        c.attach(*this);
        c.speak();
    }

virtual void update(animal& subject, int arg) 
    {
        cout << "zoo1 received notification " << arg << endl;
    }

cat1 c;
};

通过这样做，每个主题都是对动物进行静态“施法”。你的cat1

不是这种情况

Answer 2

正如Cyrs所指出的，在您的示例中，编译器尝试将static_cast Subject<animal, int>*转换为animal*，而animal和Subject<animal, int>都不会继承另一个，甚至是间接的。编译器认为这种转换是不可能的。

如果将static_cast替换为dynamic_cast，则可以在运行时评估是否可以进行此转换。在您的示例中，因为cat1幸运地是animal和Observer<animal, int>。因此，如果用户（开发人员）没有做任何错误，即如果他/她提供具有这种层次结构的类，它将始终与dynamic_cast一起使用。

因此，您可能希望通过dynamic_cast实现更强大的实现并检测编程错误。出现这样的错误，dynamic_cast将返回一个空指针。因此，您可以测试dynamic_cast是否在notify()，attach()或Subject()中返回空指针，并避免在这种情况下使用指针。

请注意，由于运行时类型评估，dynamic_cast的效率低于static_cast。

我宁愿选择Cyrs的解决方案。

正如评论中所指出的，您还应该考虑以下主题的接受答案：Should I use dynamic cast in the subject observer pattern with templates，这是一个不错的选择。

基于模板的主题观察者模式 - 我应该使用static_cast还是dynamic_cast

2 个答案: