About the observer design pattern

The design patterns from the "Gang of Four" focus heavily on solving problems using classes. However, in modern C++, there are other ways to solve the problem that might have some benefits.

Consider that you had to create two classes for the observer pattern here: an abstract base class TimeObserver, and a concrete class Clock. If you need to observe something else, or want to have an time observer that does something different than printing the time, you have to add more classes. But you are not interested in the classes, you only are interested in the function Update(). So instead you could use std::function to store observer function:

class TimeManager
{
    using Clock = std::chrono::steady_clock;
    using TimePoint = Clock::time_point;
    using Observer = std::function<void(TimePoint, TimePoint)>;

public:
    void RegisterObserver(Observer observer)
    {
        observers.push_back(observer);
    }
    …
    void NotifyObservers()
    {
        for (auto& observer: observers)
        {
             observer(time, startTime);
        }
    }
    …
private:
    std::vector<Observer> observers;
    …
};

And then you could use it like so:

int main()
{
    TimeManager timeManager;

    timeManager.RegisterObserver([](auto time, auto startTime) {
        std::cout << duration<double, std::milli>{time - startTime}.count()
                  << "ms\n";
    });
    …
}

This is slightly more efficient as well, since with virtual functions, two pointer indirections are necessary to call the actual function, whereas with std::function<> there is only a single indirection.

One drawback though is that you no longer have a pointer to an object that you can use as a handle to deregister the observer. However, that brings me to:

Deregistering issues

Your example code is correct. However, what if you had forgotten to delete the observers? Or worse, what if you deleted the observers after registering them but before calling UpdateTime()? What if you register the same observer object twice?

There are several ways in which you can avoid these issues:

• Use std::function as shown above.
• Use std::shared_ptr<TimeObserver> to manage the lifetime of the observer objects.
• Use std::unique_ptr<TimeObserver> and std::move() it when calling RegisterObserver().

All of these types will help manage the lifetime of observer objects in a safe way. They each have their pros and cons.

Use std::erase() to remove items

Instead of calling std::find() and then observerList.erase(…), you can use std::erase() since C++20. This simplifies the code and also handles erasing duplicates:

void RemoveObserver(TimeObserver* observer)
{
    std::erase(observerList, observer);
}

Avoid std::chrono::high_resolution_clock

Unfortunately, it's not well-defined what std::chrono::high_resolution_clock is. You are almost always better of using another clock. For example, std::chrono::system_clock if you care about wall clock time, something which you can compare with system clocks on other machines. Or if you want a clock that is not affected by NTP updates, leap seconds and so on, use std::chrono::steady_clock. Note that the latter is almost always a high resolution clock.

Also, avoid storing the result of std::chrono::high_resolution_clock::now() into a std::chrono::steady_clock::time_point. What would it even mean?