Linux 编写Makefile 例子 观察者模式

观察者模式实现： 

一个observe.hpp 文件

一个observe.cpp文件

一个mian.cpp 文件。

亲测，可以直接运行。

目标： 

编写一个简单的Makefile 文件， 在Linux下，直接make生成可执行文件observe.

main.cpp 文件

#include "observe.hpp"

#include <iostream>

using namespace std;

int main()

{

    Observer* p1 = new ConcreteObserverA();

    Observer* p2 = new ConcreteObserverB();

    Observer* p3 = new ConcreteObserverA();

    Subject* pSubject = new ConcreteSubjectA();

    pSubject->Attach(p1);

    pSubject->Attach(p2);

    pSubject->Attach(p3);

    pSubject->SetState("old");

    pSubject->Notify();

    cout << "-------------------------------------" << endl;

    pSubject->SetState("new");

    pSubject->Detach(p3);

    pSubject->Notify();

    return 0;

}

observe.cpp 文件

#include "observe.hpp"

#include <iostream>

#include <algorithm>

using namespace std;

Observer::Observer()

{}

Observer::~Observer()

{}

ConcreteObserverA::ConcreteObserverA()

{}

ConcreteObserverA::~ConcreteObserverA()

{}

void ConcreteObserverA::Update(Subject* pSubject)

{

    this->m_state = pSubject->GetState();

    cout << "The ConcreteObserverA is " << m_state << std::endl;

}

ConcreteObserverB::ConcreteObserverB()

{}

ConcreteObserverB::~ConcreteObserverB()

{}

void ConcreteObserverB::Update(Subject* pSubject)

{

    this->m_state = pSubject->GetState();

    cout << "The ConcreteObserverB is " << m_state << std::endl;

}

Subject::Subject()

{}

Subject::~Subject()

{}

void Subject::Attach(Observer* pObserver)

{

    this->m_lst.push_back(pObserver);

    cout << "Attach an Observer\n";

}

void Subject::Detach(Observer* pObserver)

{

    list<Observer*>::iterator iter;

    iter = find(m_lst.begin(),m_lst.end(),pObserver);

    if(iter != m_lst.end())

    {

        m_lst.erase(iter);

    }

    cout << "Detach an Observer\n";

}

void Subject::Notify()

{

    list<Observer*>::iterator iter = this->m_lst.begin();

    for(;iter != m_lst.end();iter++)

    {

        (*iter)->Update(this);

    }

}

string Subject::GetState()

{

    return this->m_state;

}

void Subject::SetState(string state)

{

    this->m_state = state;

}

ConcreteSubjectA::ConcreteSubjectA()

{}

ConcreteSubjectA::~ConcreteSubjectA()

{}

ConcreteSubjectB::ConcreteSubjectB()

{}

ConcreteSubjectB::~ConcreteSubjectB()

{}

observe.hpp 文件

#ifndef _OBSERVER_H_

#define _OBSERVER_H_

#include <iostream>

#include <list>

#include <algorithm>

using namespace std;

class Subject;

class Observer

{

public:

    ~Observer();

    virtual void Update(Subject*)=0;

protected:

    Observer();

private:

};

class ConcreteObserverA : public Observer

{

public:

    ConcreteObserverA();

    ~ConcreteObserverA();

    virtual void Update(Subject*);

protected:

private:

    string m_state;

};

class ConcreteObserverB : public Observer

{

public:

    ConcreteObserverB();

    ~ConcreteObserverB();

    virtual void Update(Subject*);

protected:

private:

    string m_state;

};

class Subject

{

public:

    ~Subject();

    virtual void Notify();

    virtual void Attach(Observer*);

    virtual void Detach(Observer*);

    virtual string GetState();

    virtual void SetState(string state);

protected:

    Subject();

private:

    string m_state;

    list<Observer*> m_lst;

};

class ConcreteSubjectA : public Subject

{

public:

    ConcreteSubjectA();

    ~ConcreteSubjectA();

protected:

private:

};

class ConcreteSubjectB : public Subject

{

public:

    ConcreteSubjectB();

    ~ConcreteSubjectB();

protected:

private:

};

#endif

Makefile 文件

生成文件名为 observe

observe : main.o observe.o
    g++ -o observe  main.o observe.o

main.o : main.cpp observe.hpp
    g++ -c main.cpp
observe.o :observe.hpp observe.cpp
    g++ -c observe.cpp
clean:
    rm observe main.o observe.o