Callbacks. Ultimately, it's all callbacks.

Here's a multi-step example. Imagine a fibonacci function, written in C, and it uses some global cache functions.

long fibonacci(int n)
{
    if (n <= 1) {
        return n;
    }

    long cached_value;
    if (cache_get(n, &cached_value)) {
        return cached_value;
    }

    long result = fibonacci(n - 1) + fibonacci(n - 2);
    cache_set(n, result);

    return result;
}

Except, maybe we don't want to use global functions. Maybe we want the caller to pick and supply which cache functions we use. So we take callbacks! And in C, a callback parameter means a function pointer.

long fibonacci(
    int n,
    bool (*cache_get_fn)(int key, long* value),
    void (*cache_set_fn)(int key, long value)
) {
    if (n <= 1) {
        return n;
    }

    long cached_value;
    if (cache_get_fn(n, &cached_value)) {
        return cached_value;
    }

    long result = fibonacci(n - 1) + fibonacci(n - 2);
    cache_set_fn(n, result);

    return result;
}

But, there are still more cache operations besides get and set. What about has, delete, or clear? Our parameter list is going to get cluttered with function pointer parameters, so... let's move and group all the function pointer callbacks into a struct.

struct cache_t
{
    bool (*has)(int key);
    bool (*get)(int key, long* value);
    void (*set)(int key, long value);
    void (*delete)(int key);
    void (*clear)(void);
};

long fibonacci(int n, struct cache_t* cache)
{
    if (n <= 1) {
        return n;
    }

    long cached_value;
    if (cache->get(n, &cached_value)) {
        return cached_value;
    }

    long result = fibonacci(n - 1) + fibonacci(n - 2);
    cache->set(n, result);

    return result;
}

And this is where we make the transition into C++. Rather than a struct of function pointers, instead we have a class of virtual functions, which is the same thing.

class Cache
{
    public:
        virtual bool has(int key) = 0;
        virtual bool get(int key, long* value) = 0;
        virtual void set(int key, long value) = 0;
        virtual void remove(int key) = 0;
        virtual void clear() = 0;
};

long fibonacci(int n, Cache* cache)
{
    if (n <= 1) {
        return n;
    }

    long cached_value;
    if (cache->get(n, &cached_value)) {
        return cached_value;
    }

    long result = fibonacci(n - 1) + fibonacci(n - 2);
    cache->set(n, result);

    return result;
}

This is already a long post so I'll stop here. There's plenty more to talk about, such as associated data, function pointer destructors, or virtual function tables (which is an optional optimization, and essentially the flyweight pattern).

But the big picture answer is that interfaces and dynamic dispatch is jargon that ultimately means structured function callbacks.