c++ - 观察者模式与继承 : Not calling the correct function

Question

我正在尝试为我为学校项目创建的游戏实现观察者模式。

我创建了 2 个虚拟类，Observer 和 Observable。

观察者.h:

#ifndef OBSERVER_H
#define OBSERVER_H
#include <vector>

class Observable;

class Observer
{
    public:
     Observer();
     virtual ~Observer();
     virtual void update(Observable* ob) =0;
};

#endif

观察者.cpp:

 #include "stdafx.h"
 #include "Observer.h"


 Observer::Observer()
 {
 }

 Observer::~Observer()
 {
 }

Observable.h:

#ifndef OBSERVEABLE_H
#define OBSERVEABLE_H
#include <vector>
#include "Observer.h"


class Observable
{
    protected:
    std::vector<Observer*> observers;
    public:
    Observable();
    virtual ~Observable();
    virtual void attach(Observer *a);
    virtual void detach(Observer *a);
    virtual void notify();
};

#endif

Observable.cpp:

#include "stdafx.h"
#include "Observable.h"

Observable::Observable()
{
}

Observable::~Observable()
{
}

void Observable::attach(Observer *a)
{
    observers.push_back(a);
}

void Observable::detach(Observer *a)
{
     for (auto it = this->observers.begin(); it < this->observers.end(); it++) 
     {

            if (*it == a) 
            {
            this->observers.erase(it);
            break;
            }
     }
 }

void Observable::notify()
{
    for (int i = 0; i < observers.size(); i++)
        observers[i]->update(this);
}

我有一个继承自Observable的Map类，和一个继承自Observer的mapView类(Map很长，我只包含了相关的功能)

map .h:

#ifndef MAP_H
#define MAP_H
#include "Observable.h"
#include <iostream>

class Map : public Observable
{
    public:
    Map();
    ~Map();
    void getLatest();
    void notify();
};

#endif

map .cpp:

#include "stdafx.h"
#include "Map.h"

Map::Map()
{
}

Map::~Map()
{
}

void Map::getLatest()
{
    using namespace std;
    cout << "This is the latest info!" << endl;
}

map View .h:

#ifndef MAP_V_H
#define MAP_V_H
#include "Observer.h"
#include "Map.h"
#include "Plants.h"

class mapView : public Observer
{
    public:
    mapView();
    ~mapView();
    void update(Map* map);
};

#endif

map View .cpp:

#include "stdafx.h"
#include "mapView.h"
#include "Map.h"

mapView::mapView()
{
}

mapView::~mapView()
{
}

void mapView::update(Map* map)
{
    map->getLatest();
}

最后，我的 main 简单地创建了一个 Map 和一个 mapView，附加了 mapView，并调用了 map.notify()

主要.cpp:

#include "stdafx.h"
#include "setUp.h"
#include "Map.h"
#include "mapView.h"

int main()
{
    Map gameMap;
    mapView view;
    gameMap.attach(&view);

    gameMap.notify();

    return 0;
}

我在这里遇到了很多问题。我无法创建 mapView 项目，因为编译器说我从未实现更新的覆盖版本(Observable* ob)....我尝试使用 update(Map* map)但看起来尽管 Map 继承自 Observable，但它似乎不能算作相同的签名，因此无法编译。

我试图更改我的 mapView::update() 函数以获取指向 Observable 的指针，但这不会起作用，因为该函数调用了 Map 类中的某些内容。

然后我尝试将更新函数更改为不是虚函数(在虚类中实现为空)，但似乎任何时候我尝试传递 Map 进行更新时，它都会调用基类函数而不是 map View 版本。换句话说，永远不会调用 getLatest()。

我现在很困惑，因为这与我认为多态性的工作方式背道而驰。如果可能的话，将不胜感激一些帮助或见解!

谢谢，

Answer 1

您的基类声明:

virtual void update(Observable* ob) =0;

您的派生类声明:

void update(Map* map);

这些不是同一个签名。如果您使用新的 override 关键字，您会在编译时看到您实际上并没有覆盖虚拟方法。

如果您知道您只会得到Map，那么您可以只使用static_cast。但是使用 dynamic_cast 更安全:

void update(Observable* o) override { // now we're ok
    if (auto map = dynamic_cast<Map*>(o)) {
        // okay, got a Map
        // ....
    }
    else {
        // huh?
    }
}

---

超简类型理论题外话。覆盖的典型规则是返回co变体和参数类型contra变体。您可以指定更派生的返回类型或更基本的参数类型。以这种方式考虑 - 如果您有一个基类函数获取并返回一个 Car*...您的参数可以是一个 Car*(这正是我们所期望的)，或者它可以是 Vehicle*(因为你可以用 Vehicle 做任何事情，你也可以用 Car 做 - 这仍然有效)，但它不能是 SportsCar*(因为调用者可能会传递给您一辆不是 SportsCar 的 Car 并且有理由期望它工作!)派生类只接受 Map 是没有意义的 - 你必须能够接受任何 Observable，甚至不能接受 Map 啊!