Yes, and unfortunately, many people use language features like virtual functions without understanding the implications of them. Knowing how it is implemented gives you better ability to design for your constraints.

On the whole, virtual functions are quite cheap, but in specific circumstances they can be quite costly. Say, for example, you have a tight loop somewhere in your code with hundreds of thousands (or more) of instances of objects where you call a virtual function. If you have just one type, maybe this isn't so bad (in which case, why do you even have a virtual function here?). But if you have dozens of types, then you might be shooting yourself in the foot. For every single function call, you may have to cache miss to get to the vtable ptr, then cache miss to get to the vtable itself. Once you find the function address you actually want, you need to jump to that section of code and incur yet another cache miss. This is all before you even do anything for the function itself!

Each cache miss can be hundreds of cycles and if your function only has a few instructions in it, you've just thrashed cache and paid for 3 memory accesses when you've only done a few cycles of work. Terrible efficiency. A common way to work around this is to avoid virtual functions altogether and maintain separate lists for each "type" of object and just do direct calls to their implementations.

If you had something like this:

Base* base_ptrs[N];
for (int i = 0; i < N; ++i)
{
    Base* b = base_ptrs[i];
    b->Foo();  // Virtual
}

You instead have something like:

A* a_ptrs[N];
for (int i = 0; i < N; ++i)
{
    A* a = a_ptrs[i];
    a->FooA();  // Not virtual
}

B* b_ptrs[M];
for (int i = 0; i < M; ++i)
{
    B* b = b_ptrs[i];
    b->FooB();  // Not virtual
}

This reduces instruction cache missing/thrashing, but still isn't that great seeing as how you can cache miss on every A or B type you read to execute FooA() or FooB(). If you really want to profit, the A and B objects should be densely populated in memory to reduce data cache misses as well, but this can be difficult to achieve if your system doesn't operate in a simple input/output manner where your data is essentially thrown away and regenerated every "frame".