Dynamic dispatch ਰਨਟਾਈਮ ਮਕੈਨਿਜ਼ਮ ਹੈ ਜੋ ਇਹ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ method implementation ਚਲਾਉਣਾ ਹੈ, ਜੋ object ਦੀ ਅਸਲ ਕਿਸਮ ਦੇ ਆਧਾਰ 'ਤੇ ਹੈ, ਨਾ ਕਿ variable ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੀ ਕਿਸਮ ਦੇ ਆਧਾਰ 'ਤੇ। ਜ਼ਿਆਦਾਤਰ class-based ਭਾਸ਼ਾਵਾਂ ਇਸ ਨੂੰ virtual method table (vtable) ਨਾਲ ਲਾਗੂ ਕਰਦੀਆਂ ਹਨ।
ਹਰੇਕ class ਦੇ ਕੋਲ ਆਪਣੇ method implementations ਦੇ ਲਈ pointers ਦੀ ਇੱਕ ਟੇਬਲ ਹੈ। ਹਰੇਕ object ਕੋਲ ਆਪਣੀ class ਦੇ vtable ਵਾਲਾ ਇੱਕ ਲੁਕਵਾਂ pointer ਹੈ। ਇੱਕ virtual call ਇਸ ਤਰ੍ਹਾਂ ਬਣ ਜਾਂਦਾ ਹੈ:
Animal a = new Dog();
a.speak();
a ──▶ Dog object ──▶ [Dog vtable]
speak() ──▶ Dog.speak() ← chosen at RUNTIME
Compiler Animal.speak ਨੂੰ hard-code ਨਹੀਂ ਕਰਦਾ; ਇਹ "call slot N of whatever vtable this object points to" emit ਕਰਦਾ ਹੈ।
Animal a = new Dog(); // declared Animal, actual Dog
a.speak(); // → Dog.speak(), because dispatch uses the OBJECT
| Language | Default | Notes |
|---|---|---|
| Java | Virtual by default | final/static/private are non-virtual |
| C++ | Non-virtual by default | Must mark virtual for dynamic dispatch |
| Python | Always dynamic | Method lookup via the object's dict/MRO |
ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਖਰਚ (ਇੱਕ indirection) ਹੈ ਅਤੇ ਇਹ inlining ਨੂੰ ਰੋਕਦਾ ਹੈ। C++ ਵਿੱਚ, virtual ਨੂੰ ਭੁੱਲ ਜਾਣਾ ਮਤਲਬ ਹੈ ਕਿ calls static ਨਾਲ bind ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ overrides ਸੂਖਮੀ ਨਾਲ ਨਹੀਂ ਕਾਲ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ — ਇੱਕ ਬਾਰੀਕ bug।
Dispatch ਨੂੰ ਸਮਝਣਾ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿਉਂ overriding ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਕਿਉਂ ਘੋਸ਼ਣਾ ਕੀਤੀ ਕਿਸਮ ਵਿਹਾਰ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰਦੀ — ਉਲਝਣ ਦਾ ਇੱਕ ਆਮ ਸਰੋਤ।
ਇਹ ਵਾਸਤਵਿਕ ਨਤੀਜਿਆਂ ਨੂੰ ਵੀ ਸਪਸ਼ਟ ਕਰਦਾ ਹੈ: virtual calls ਦੀ performance ਲਾਗਤ, ਕਿਉਂ constructors ਨੂੰ virtual methods ਨੂੰ ਕਾਲ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ, ਅਤੇ ਕਿਉਂ C++ ਨੂੰ virtual ਨੂੰ explicitly ਲੋੜ ਹੈ।