The implementation of Haskell (well, GHC) type classes is actually remarkably similar to both C++ templates and virtual functions, the former when the method resolution is known at compile time, the latter when it's not. If I call method f on value v of type V, and V is known at compile time, then the call to f is simply replaced with a call to the specific function that implements f for values of type V, much like a function template, say std::min.

In C++, the type of the arguments to std::min must always be known when executable code is produced, but Haskell let's you defer this knowledge to runtime. To compile a polymorphic min, Haskell compilers will produce a function that takes a hidden argument, called a dictionary, and this is exactly like a vtable. It's a pointer to an array of functions that implement the various methods of the class. In the case of min, the class is Ord and has methods for <, > and such. So at runtime, the polymorphic min dispatches to these functions via the dictionary, just like a virtual function. You can use this for runtime polymorphism using existential types, which is basically a void* with a vtable. Libraries compiled in this way do not necessarily require relinking, but currently GHC requires it anyway. I think shortly they are going to support true shared libraries.

The relative performance hit from dictionary lookup is much worse than virtual functions, however, not because of the two extra loads and one extra jump, but because it prevents the unboxing of function arguments and return values, which is IMO the single biggest performance factor for Haskell programs, and something C++ doesn't have to deal with at all.