பாயும் பதித்தல் என்பது ஒரு நேர இயக்கக் பொறிமுறை ஆகும், இது எந்த முறை செயல்படுத்தலை இயக்க வேண்டும் என்பதை *பொருளின் உண்மையான வகைத்தின் அடிப்படையில் முடிவு செய்கிறது, மாறுபட்ட மாறியின் தெரிவிக்கப்பட்ட வகை அல்ல. பெரும்பாலான வகுப்பு-அடிப்படையிலான மொழிகள் இதை மெய்நிக முறை அட்டவணை (vtable) கொண்டு செயல்படுத்துகின்றன.
பிரতி வகுப்புக்கு அதன் முறை செயல்படுத்தலுக்கான சுட்டுக்களின் அட்டவணை உள்ளது. பிரतி பொருளுக்கு அதன் வகுப்பின் vtable-க்கு ஒரு மறைந்த சுட்டி உள்ளது. ஒரு மெய்நிక அழைப்பு:
Animal a = new Dog();
a.speak();
a ──▶ Dog object ──▶ [Dog vtable]
speak() ──▶ Dog.speak() ← chosen at RUNTIME
கம்பைலர் Animal.speak-ஐ கடினமாக குறியீடு செய்யாது; இது "இந்த பொருள் சுட்டிக்கும் vtable-ல் சலட N-ஐ அழையும்."
Animal a = new Dog(); // declared Animal, actual Dog
a.speak(); // → Dog.speak(), because dispatch uses the OBJECT
| மொழி | இயல்புரிமை | குறிப்புகள் |
|---|---|---|
| Java | மெய்நிக இயல்புரிமை | final/static/private என்பவை மெய்நிகம் அல்ல |
| C++ | மெய்நிகம் அல்லாத இயல்புரிமை | பாயும் பதித்தலுக்கு virtual-ஐ குறிக்க வேண்டும் |
| Python | எப்போதும் பாயும் | பொருளின் dict/MRO மூலம் முறை தேடல் |
ஒரு சிறிய செலவு (ஒரு மறைமுகம்) உள்ளது மற்றும் இது உள்ளீட்டைத் தடுக்கிறது. C++-ல், virtual-ஐ மறப்பது அழைப்புகளை நிலையாக பிணைக்கிறது மற்றும் மேலெழுதல்கள் அமைதியாக மாறாது அழைக்கப்படுகின்றன — ஒரு நுட்பமான பிழை.
பதித்தலைப் புரிந்துகொள்வது ஏன் மேலெழுதல் செயல்படுகிறது மற்றும் ஏன் தெரிவிக்கப்பட்ட வகை நடத்தையைத் தீர்மானிக்கவில்லை என்பதை விளக்குகிறது — குழப்பத்தின் பொதுவான மூலமாகும்.
இது உண்மையான விளைவுகளையும் தெளிவுபடுத்துகிறது: மெய்நிக அழைப்புகளின் செயல்திறன் செலவு, ஏன் கட்டுமாணங்கள் மெய்நிக முறைகளை அழைக்கக்கூடாது, மற்றும் ஏன் C++ virtual-ஐ வெளிப்படையாக தேவை.