Observer pattern implementation I'm reading Head First Design Patterns and I'm currently reading about the observer pattern. Is what I produced correct?

#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;

class ObserverInterface 
{
public:
    virtual void update(std::string message) = 0;
};

class concreteObserver : ObserverInterface 
{
    std::string name;
    std::string message;
public:
    concreteObserver(std::string name)
        :name(name)
    {}
    void update(std::string message)
    {
        this-&gt;message = message;

        std::cout &lt;&lt; "Dear " &lt;&lt; name &lt;&lt; ", " &lt;&lt; message &lt;&lt; " from eBay" &lt;&lt; std::endl;
    }
};

class SubjectInterface 
{
public:
    void subscribe(concreteObserver *subscriber)
    {
        subscribers.push_back(subscriber);
    }
    void unsubscribe(concreteObserver *subscriber)
    {
        subscribers.erase(std::remove(subscribers.begin(), subscribers.end(), subscriber), subscribers.end());
    }
    void notify(std::string message)
    {
        std::vector&lt;concreteObserver*&gt;::const_iterator itr = subscribers.begin();
        while (itr != subscribers.end())
        {
            (*itr)-&gt;update(message);
            ++itr;
        }
    }
private:
    std::vector&lt;concreteObserver*&gt; subscribers;
};

class concreteSubject : public SubjectInterface 
{
public:
    void newMessage(std::string msg)
    {
        notify(msg);
    }
};

int main(int argc, char* argv[])
{
    // EBAY
    concreteSubject ebay;

    // USERS
    concreteObserver user1("Steven");
    concreteObserver user2("John");

    // SUBSCRIBERS TO EBAY
    ebay.subscribe(&amp;user1);
    ebay.subscribe(&amp;user2);

    // EBAY SENDS NEW PROMOTIONS TO SUBSCRIBERS
    ebay.newMessage("enjoy free weekend listings");

    // UNSUBSCRIBE FROM EBAY
    ebay.unsubscribe(&amp;user2);

    // EBAY SENDS NEW PROMOTION TO SUBSCRIBERS
    ebay.newMessage("free listings extended until 1st August");

    std::cout &lt;&lt; std::endl &lt;&lt; std::endl;
    system("pause");
    return 0;
}
Inheritance is by default private
class concreteObserver : ObserverInterface 
                        ^^^^ Need public: here

Mark overriden methods:
void update(std::string message) // override ???

endl vs '\n'
Don't use endl unless you absolutely want to flush the buffer.
Probably OK here. Just wanted to note it.
Don't pass pointers:
    void subscribe(concreteObserver *subscriber)

Is subscriber every going to be NULL?
Do you need to check if subscriber has been destroyed?
Personally. I would pass by reference and document that a subject must live longer than the observers. Not that just because you pass by reference does not mean you can hold a pointer.
    void subscribe(concreteObserver&amp; subscriber) // pass by reference
    {
        subscribers.push_back(&amp;subscriber);      // but save pointer.
    }

But if you have a lot of dynamically allocated stuff this may not be suffecient. You could pass a std::weak_ptr then check of the subscriber is still available before sending the message.
Use the new foreach loop
        std::vector&lt;concreteObserver*&gt;::const_iterator itr = subscribers.begin();
        while (itr != subscribers.end())
        {
            (*itr)-&gt;update(message);
            ++itr;
        }

Easier to write as:
        for(auto&amp; sub: subscribers) {
           sub-&gt;update(message);
        }