需要有关观察者 c++ 更新的帮助

Question

我有一个订购饮料类型的程序。我正在尝试实现观察者模式，因此当下订单时，手机/观察者将显示订单，基本上让他们知道更新。

我只是不知道该怎么做。如果我在 update()order 类中传递 TheOrder 类..我会收到很多错误。太多了，无法发布.. update() 位于观察者和手机以及 TheOrder 类中..

这是我的观察者类：

#ifndef _OBSERVER_
#define _OBSERVER_

#include <string>
//#include "TheOrder.h"

namespace CoffeeHouse {
namespace Observers {

//class Subject;
class Observer {

protected: virtual ~Observer() = 0 {
};
public: 
//  virtual 
    virtual void update()= 0;
};

} // namespace Observer
} // namespace HeadFirstDesignPatterns

#endif

这是观察者具体类，

#ifndef _CELLPHONE1_
#define _CELLPHONE1_
#include <iostream>
using namespace std;

namespace CoffeeHouse {
namespace Observers {

class CellPhone1: public Observer {
public: 
    std::string _number;


    CellPhone1(std::string number){
        _number = number;
    }

    void update()
 {
     std::cout << "BUZZZZZZZ - CellPhone #" << _number << " your order is ready " << endl;
}
};

} // namespace Observer
} //

#endif

这里是主题类，

#ifndef _SUBJECT_
#define _SUBJECT_

#include "Starbuzz.h"
//#include "Starbuzz2.h"
#include "Observer.h"
#include <list>
#include "Beverage.h"

namespace CoffeeHouse {
namespace Observers {

class Subject {

protected: virtual ~Subject() = 0 {
};
public: virtual void registerObserver( Observer* o ) = 0;
public: virtual void removeObserver( Observer* o ) = 0;
public: virtual void notifyObservers() = 0;
};

} // namespace Observer
} 

#endif

这里是主题具体类

#ifndef _THE_ORDER_
#define _THE_ORDER_


#include "Beverage.h"
#include <list>
#include <iostream>
#include "Order.h"

#pragma once;
//class Order;
using namespace CoffeeHouse::Decorator;
namespace CoffeeHouse {
namespace Observers {


class TheOrder : public Subject {



 private: mutable std::list< Observer* > _observers;
private: mutable std::list< Order* > _orders;

//public: virtual ~Order() = 0 
//public: ~TheOrder();
public: void NewOrder(Beverage* bev, Observer* cellphone)
        {
        //  _orders.push_front(new Order(bev, cellphone));
       //_//observers.push_front(new Order(bev));

        }

public: void registerObserver( Observer* o ) { assert( o );
    _observers.push_back(o);
}

public: void removeObserver( Observer* o ) { assert( o );
    _observers.remove(o);
}

public: void notifyObservers()  {
    for( std::list< Observer* >::iterator iterator = _observers.begin(); _observers.end() != iterator; ++iterator ) {
        Observer* observer = *iterator;
        observer->update();

    }
}


};
//}
} // namespace Observer
} // namespace CoffeeHouse

#endif

，这里是观察者具体类

#ifndef _CELLPHONE1_
#define _CELLPHONE1_
#include <iostream>
using namespace std;

namespace CoffeeHouse {
namespace Observers {

class CellPhone1: public Observer {
public: 
    std::string _number;


    CellPhone1(std::string number){
        _number = number;
    }

    void update()
 {
     std::cout << "BUZZZZZZZ - CellPhone #" << _number << " your order is ready " << endl;
}
};

} // namespace Observer
} //

#endif

main()

#include "Starbuzz.h"   //just header files
#include "Starbuzz2.h"  // just header files
#include "Subject.h"

#include "TheOrder.h"
#include "CellPhone2.h"
#include "CellPhone1.h"

using namespace CoffeeHouse::Decorator;
using namespace CoffeeHouse::Observers;


int main( int argc, char* argv[] ) 
{

Beverage* beverage2 = new DarkRoast();
beverage2 = new Mocha(beverage2);
beverage2 = new Mocha(beverage2);
beverage2 = new Whip(beverage2);

std::cout << "Current Orders: "  << endl;
std::cout << beverage2->getDescription() 
    << " $" 
    << beverage2->cost() 
    << std::endl;

Beverage* beverage3 = new HouseBlend();
beverage3 = new Soy(beverage3);
beverage3 = new Mocha(beverage3);
beverage3 = new Whip(beverage3);
std::cout << beverage3->getDescription() 
    << " $" 
    << beverage3->cost() 
    << std::endl;

delete beverage3;
delete beverage2;
//delete beverage;

Bagel* bagel = new Plain();
std::cout.setf( std::ios::showpoint);
std::cout.precision(3);
std::cout << bagel->getDescription() 
    << " $" 
    << bagel->cost() 
    << std::endl;

Bagel* bagel2 = new Raisen();
bagel2 = new Myhummus(bagel2);
bagel2 = new SesemeSeed(bagel2);
bagel2 = new CreameCheese(bagel2);
std::cout << bagel2->getDescription() 
    << " $" 
    << bagel2->cost() 
    << std::endl;



Bagel* bagel3 = new Onion();
bagel3 = new Myhummus(bagel3);
bagel3 = new SesemeSeed(bagel3);
bagel3 = new CreameCheese(bagel3);
std::cout << bagel3->getDescription() 
    << " $" 
    << bagel3->cost() 
    << std::endl;


TheOrder* orders = new TheOrder();
CellPhone1* cellphone1 = new CellPhone1("1");
orders->registerObserver(cellphone1);
orders->notifyObservers();

TheOrder* order = new TheOrder();
CellPhone1* obj2 = new CellPhone1("3");
order->registerObserver(obj2);
    order->notifyObservers();


return 0;
}

我只是想将订单发送到 cellphone1 类中，以便我可以显示每个不同的订单..我想我需要通过更新功能发送它..

因为在 cellphone1 中是观察者，所以我想显示在那里订购..

在TheOrder类中有一个notifyObservers()函数我需要传递这个指针吗？还

Answer 1

有两种常见的方法来实现观察者模式。第一种情况下，每个观察者都持有对可观察对象的引用。在您的情况下，您需要告诉每个 Cellphone 对象它正在等待哪个 Order 对象。如果你的每部手机最多只有一个订单，那么这不会太棘手。如果你的每部手机的订单数量超过了订单数量，那么你就必须在手机类中以某种方式进行管理。

第二种常见方法（以及我在您的情况下会做的事情）是在 update() 方法中将 Observable 传递给观察者。在您的情况下，您可以将 Observer 及其所有子类中的 update 签名更改为：

void update(TheOrder *order);

然后您将可以访问手机 中的特定已完成订单更新方法。

Answer 2

需要解决的一件事：

protected: virtual ~Observer() = 0 { };