Now we have a standard way to call observers

Instead of having different methods to call observers (like update, and
displayStuff) all you need to do now is just call your reference to the
object.

Next step is to keep the list of observers in one place. That way, when
we need to add another observer, instead writing it into the lambda,
we'll just add it to a list.

(obeserver pattern observation pattern)
Now we have a c++11 observer pattern

We now have a really nice c++11 observer pattern.

It differs from the Java version in several ways:

 1. Instead of an interface, we just declare a simple generic type
    'Observer' which is a callable object, taking the three data params.
 2. The subject (the weather station) only need know about and notify a
    single observer.
 3. The list of observers is maintained by the app. This is quite good
    as it is the app that manages their lifetime too.
 4. There is no need for an observer to know about any interfaces. All
    it need do is provide a call operator that takes three doubles. This
    gives some very loose coupling, but still enables compile time error
    checking.
 5. In Java everything is a shared pointer (reference counted and
    garbage collected). In our app, the app itself manages object
    lifetimes.
 6. If we went the Java way, the list of observers would have been a
    list of pointers to virtual objects, and a notification would be a
    lookup in a virtual method table. However the list of observers here
    is a list of std::function objects that *may* be inlined by the
    compiler when actually called; in the worst case it'll follow 2
    pointers to get the address of a method, which is still faster than
    a vtable lookup.

(evolution of the observer pattern lesson)