C++ ਵਿੱਚ ਆਪਰੇਟਰ ਦੀ ਚੋਣ ਅਤੇ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ
ਦੇ ਕਸਟਮ ਲਾਗੂਕਰਨ ਨਵਾਂ ਅਤੇ ਮਿਟਾਓ C++ ਵਿੱਚ ਆਪਰੇਟਰ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਦੀ ਬਹੁਤ ਵੱਡੀ ਆਜ਼ਾਦੀ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ। ਇਹ ਆਪਰੇਟਰ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਉਹਨਾਂ ਦੀਆਂ ਕਲਾਸਾਂ ਦੇ ਅੰਦਰ ਮੈਮੋਰੀ ਦੀ ਵੰਡ ਅਤੇ ਵੰਡ 'ਤੇ ਨਿਯੰਤਰਣ ਦਿੰਦੇ ਹਨ। ਸਬ-ਕਲਾਸਿੰਗ ਉਲਝਣ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੀ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਦੀ ਚੋਣ ਕਰਦੇ ਸਮੇਂ ਮਿਟਾਓ ਵਸਤੂ ਦੇ ਵਿਨਾਸ਼ ਲਈ ਆਪਰੇਟਰ.
C++ ਵਿੱਚ ਓਪਰੇਟਰ ਓਵਰਲੋਡਿੰਗ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਹੀ ਦੀ ਚੋਣ ਨਵਾਂ ਓਪਰੇਟਰ ਸਿੱਧਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ ਕਿਉਂਕਿ ਅਸਲ ਕਲਾਸ ਨੂੰ ਵੰਡ ਵੇਲੇ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਢੁਕਵੇਂ ਡਿਲੀਟ ਓਪਰੇਟਰ ਨੂੰ ਚੁਣਨਾ ਵਧੇਰੇ ਸੂਖਮ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਇੱਕ ਬੇਸ ਕਲਾਸ ਪੁਆਇੰਟਰ ਇੱਕ ਪ੍ਰਾਪਤ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਨਾਲ ਲਿੰਕ ਕਰਦਾ ਹੈ।
ਜਦੋਂ ਇੱਕ ਬੇਸ ਕਲਾਸ ਪੁਆਇੰਟਰ ਇੱਕ ਪ੍ਰਾਪਤ ਕਲਾਸ ਆਬਜੈਕਟ ਨੂੰ ਮਿਟਾ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਕੀ C++ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਮਿਟਾਓ ਅਧਾਰ ਜਾਂ ਪ੍ਰਾਪਤ ਕਲਾਸ ਤੋਂ ਓਪਰੇਟਰ? ਇਸ ਫੈਸਲੇ ਦਾ ਮੈਮੋਰੀ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਅਤੇ ਮੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਵਿਲੱਖਣ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਐਲਗੋਰਿਦਮ ਵਾਲੀਆਂ ਕਲਾਸਾਂ ਵਿੱਚ ਕਾਫ਼ੀ ਪ੍ਰਭਾਵ ਪੈਂਦਾ ਹੈ।
ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਅਧਿਐਨ ਕਰਦੇ ਹਾਂ ਕਿ ਕਿਵੇਂ g++ ਡਿਲੀਟ ਕਰਨ ਵਾਲੇ ਆਪਰੇਟਰ ਦੀ ਚੋਣ ਨੂੰ ਹੈਂਡਲ ਕਰਦਾ ਹੈ ਜਦੋਂ ਸਬ-ਕਲਾਸ ਇਸ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦੇ ਹਨ। ਅਸੀਂ ਇਹ ਦਿਖਾਉਣ ਲਈ ਇੱਕ ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਕਿ C++ ਰਨਟਾਈਮ ਕਿਸ ਤਰ੍ਹਾਂ ਦਾ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਮਿਟਾਓ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਅਭਿਆਸ ਵਿੱਚ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।
| ਹੁਕਮ | ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ |
|---|---|
| operator delete | ਇਹ ਡਿਲੀਟ ਆਪਰੇਟਰ ਦਾ ਅਨੁਕੂਲਿਤ ਲਾਗੂਕਰਨ ਹੈ। C++ ਵਿੱਚ, ਤੁਸੀਂ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦੇ ਹੋ ਆਪਰੇਟਰ ਮਿਟਾਓ ਤੁਹਾਡੀ ਕਲਾਸ ਲਈ ਕਸਟਮ ਮੈਮੋਰੀ ਡੀਲੋਕੇਸ਼ਨ ਵਿਵਹਾਰ ਬਣਾਉਣ ਲਈ। ਜਿਵੇਂ ਕਿ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਦੇਖਿਆ ਗਿਆ ਹੈ, ਮੈਮੋਰੀ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ std::free(ptr) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। |
| operator new | ਇਸੇ ਤਰ੍ਹਾਂ ਨੂੰ ਆਪਰੇਟਰ ਮਿਟਾਓ, ਦਾ ਇਹ ਕਸਟਮ ਲਾਗੂ ਕਰਨਾ ਆਪਰੇਟਰ ਨਵਾਂ ਤੁਹਾਨੂੰ ਕਸਟਮਾਈਜ਼ਡ ਮੈਮੋਰੀ ਵੰਡ ਵਿਵਹਾਰ ਨੂੰ ਸੈੱਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇਹ std::malloc(ਆਕਾਰ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਗਿਆ ਸੀ ਅਤੇ ਇੱਕ ਕਸਟਮ ਸੁਨੇਹਾ ਭੇਜਣ ਲਈ ਵਰਤਿਆ ਗਿਆ ਸੀ ਜੋ ਇਹ ਦਰਸਾਉਂਦਾ ਸੀ ਕਿ ਕਿਹੜੀ ਕਲਾਸ ਨੇ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕੀਤੀ ਹੈ। |
| virtual destructor | ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਮਿਟਾਉਣ ਲਈ ਬੇਸ ਕਲਾਸ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਵਰਚੁਅਲ ਵਿਨਾਸ਼ਕਾਰੀ ਉਚਿਤ ਵਿਨਾਸ਼ਕਾਰੀ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਿੱਚ, X ਅਤੇ ArenaAllocatedX ਦੋਵੇਂ ਮੈਮੋਰੀ ਡੀਲਲੋਕੇਸ਼ਨ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਵਰਚੁਅਲ ਡਿਸਟ੍ਰਕਟਰਾਂ ਨੂੰ ਨਿਯੁਕਤ ਕਰਦੇ ਹਨ। |
| gtest | ਦ gtest ਫਰੇਮਵਰਕ (GoogleTest) ਦੀ ਵਰਤੋਂ ਯੂਨਿਟ ਟੈਸਟ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਇਹ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸਹੀ ਹੈ ਮਿਟਾਓ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਮੈਮੋਰੀ ਵੰਡ ਅਤੇ ਡੀਲਲੋਕੇਸ਼ਨ ਐਕਸ਼ਨ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਜਾਂਚੇ ਗਏ ਹਨ। |
| ASSERT_EQ | ਤੋਂ ਇਹ ਮੈਕਰੋ gtest ਲਾਇਬ੍ਰੇਰੀ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਕੀ ਦੋ ਮੁੱਲ ਬਰਾਬਰ ਹਨ, ਜੋ ਕਿ ਟੈਸਟਿੰਗ ਕੋਡ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ ਇਸ ਕੇਸ ਵਿੱਚ ਸਰਲ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਇਸਦੀ ਵਰਤੋਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਟੈਸਟਿੰਗ ਵਿੱਚ ਮੈਮੋਰੀ ਸਥਿਤੀਆਂ ਜਾਂ ਮਿਟਾਉਣ ਦੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। |
| vptr | vptr ਇੱਕ ਲੁਕਿਆ ਹੋਇਆ ਪੁਆਇੰਟਰ ਹੈ ਜੋ ਵਰਚੁਅਲ ਫੰਕਸ਼ਨਾਂ ਵਾਲੀਆਂ ਕਲਾਸਾਂ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਵਰਚੁਅਲ ਟੇਬਲ (VTable) ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਵਰਚੁਅਲ ਫੰਕਸ਼ਨਾਂ ਦੇ ਪਤੇ ਹੁੰਦੇ ਹਨ। ਸਮਝ vptr ਦੱਸਦਾ ਹੈ ਕਿ ਆਬਜੈਕਟ ਦੀ ਗਤੀਸ਼ੀਲ ਕਿਸਮ ਦੇ ਆਧਾਰ 'ਤੇ ਉਚਿਤ ਡਿਲੀਟ ਓਪਰੇਟਰ ਕਿਉਂ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। |
| VTable | ਏ VTable (ਵਰਚੁਅਲ ਟੇਬਲ) ਇੱਕ ਢਾਂਚਾ ਹੈ ਜੋ ਵਰਚੁਅਲ ਤਰੀਕਿਆਂ ਨਾਲ ਹਰੇਕ ਕਲਾਸ ਲਈ ਵਰਚੁਅਲ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਦਰਭਾਂ ਨੂੰ ਕਾਇਮ ਰੱਖਦਾ ਹੈ। ਇਹ ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਲਾਸਾਂ ਲਈ ਢੁਕਵੇਂ ਡਿਲੀਟ ਓਪਰੇਟਰ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ। |
| malloc | ਦ malloc ਫੰਕਸ਼ਨ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਕਸਟਮ ਆਪਰੇਟਰ ਨਵਾਂ ਸਿੱਧੇ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ 'ਤੇ ਜ਼ੋਰ ਦੇਣ ਅਤੇ ਵੱਖ-ਵੱਖ ਵੰਡ ਐਲਗੋਰਿਦਮ ਦੀ ਜਾਂਚ ਕਰਨ ਵੇਲੇ ਵਧੇਰੇ ਲਚਕਤਾ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਨਵੇਂ ਦੀ ਬਜਾਏ ਵਰਤਿਆ ਗਿਆ ਸੀ। |
C++ ਵਿੱਚ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਅਤੇ ਮਿਟਾਓ ਆਪਰੇਟਰ ਚੋਣ
ਪਹਿਲਾਂ ਪੇਸ਼ ਕੀਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਇਸ ਗੱਲ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੀਆਂ ਹਨ ਕਿ C++ ਉਚਿਤ ਨੂੰ ਕਿਵੇਂ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਮਿਟਾਓ ਓਪਰੇਟਰ ਜਦੋਂ ਸਬਕਲਾਸ ਆਬਜੈਕਟ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ। C++ ਨੂੰ ਓਵਰਲੋਡ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਨਵਾਂ ਅਤੇ ਮਿਟਾਓ ਕਸਟਮ ਮੈਮੋਰੀ ਵੰਡ ਅਤੇ ਡੀਲਲੋਕੇਸ਼ਨ ਐਲਗੋਰਿਦਮ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਆਪਰੇਟਰ। ਇਹ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਢੁਕਵਾਂ ਹੈ ਜਿੱਥੇ ਉਪ-ਕਲਾਸਾਂ ਵਿੱਚ ਉਹਨਾਂ ਦੀਆਂ ਬੇਸ ਕਲਾਸਾਂ ਨਾਲੋਂ ਵੱਖਰੀ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਲੋੜਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਉਦਾਹਰਨ ਸਕ੍ਰਿਪਟਾਂ ਇੱਕ ਬੇਸ ਕਲਾਸ ਬਣਾ ਕੇ ਇਸਨੂੰ ਦਿਖਾਉਂਦੀਆਂ ਹਨ ਐਕਸ ਅਤੇ ਇੱਕ ਉਪ-ਕਲਾਸ ArenaAllocatedX, ਦੇ ਕਸਟਮ ਲਾਗੂ ਕਰਨ ਦੇ ਨਾਲ ਦੋਵੇਂ ਨਵਾਂ ਅਤੇ ਮਿਟਾਓ ਆਪਰੇਟਰ
ਪਹਿਲੀ ਸਕਰਿਪਟ ਵਿੱਚ, ਦ ਨਵਾਂ ਅਤੇ ਮਿਟਾਓ ਓਪਰੇਟਰਾਂ ਨੂੰ ਮੈਮੋਰੀ ਵੰਡ ਅਤੇ ਖਾਲੀ ਕਰਨ ਦੌਰਾਨ ਨਿਰਧਾਰਤ ਸੁਨੇਹੇ ਪੈਦਾ ਕਰਨ ਲਈ ਓਵਰਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਬੇਸ ਕਲਾਸ ਐਕਸ ਇੱਕ ਸਿੰਗਲ ਲਾਗੂਕਰਨ ਹੈ, ਪਰ ਸਬਕਲਾਸ ArenaAllocatedX ਇਸ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦਾ ਹੈ। ਮੁੱਖ ਟੇਕਵੇਅ ਇਹ ਹੈ ਕਿ C++ ਦਾ ਕਿਹੜਾ ਸੰਸਕਰਣ ਕਿਵੇਂ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਮਿਟਾਓ ਕਿਸੇ ਵਸਤੂ ਦੇ ਨਸ਼ਟ ਹੋਣ 'ਤੇ ਵਰਤਣ ਲਈ ਆਪਰੇਟਰ। ਦੋਵਾਂ ਲਈ ਸਹੀ ਆਪਰੇਟਰ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ ਐਕਸ ਅਤੇ ArenaAllocatedX, ਜਿਵੇਂ ਕਿ ਵਸਤੂ ਦੀ ਗਤੀਸ਼ੀਲ ਕਿਸਮ ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ, ਨਾ ਕਿ ਪੁਆਇੰਟਰ ਦੀ ਕਿਸਮ (ਜੋ ਕਿ X*).
ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਦੀ ਧਾਰਨਾ ਨੂੰ ਪੇਸ਼ ਕਰਦੀ ਹੈ vptr ਅਤੇ VTable. ਇਹ ਸਮਝਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹਨ ਕਿ ਕਿਵੇਂ C++ ਵਰਚੁਅਲ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਡਿਸਪੈਚ ਕਰਦਾ ਹੈ, ਵਿਨਾਸ਼ਕਾਂ ਸਮੇਤ। ਹਾਲਾਂਕਿ ਡਿਲੀਟ ਓਪਰੇਟਰ VTable ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ, ਵਰਚੁਅਲ ਡਿਸਟ੍ਰਕਟਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਣ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦਾ ਹੈ ਕਿ ਆਬਜੈਕਟ ਦੀ ਗਤੀਸ਼ੀਲ ਕਿਸਮ ਦੇ ਅਧਾਰ 'ਤੇ ਸਹੀ ਡਿਲੀਟ ਓਪਰੇਟਰ ਨੂੰ ਬੁਲਾਇਆ ਗਿਆ ਹੈ। ਵਿਨਾਸ਼ਕਾਰੀ ਗਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਜਦੋਂ ਏ X* ਪੁਆਇੰਟਰ a ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ ArenaAllocatedX ਵਸਤੂ, ਉਪ-ਕਲਾਸ ਦਾ ਮਿਟਾਓ ਓਪਰੇਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਅੰਤਿਮ ਸਕ੍ਰਿਪਟ GoogleTest ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਜੋੜਦੀ ਹੈ। ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਢੁਕਵੇਂ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਫੰਕਸ਼ਨ ਵੱਖ-ਵੱਖ ਸੰਦਰਭਾਂ ਵਿੱਚ ਲਾਗੂ ਕੀਤੇ ਗਏ ਹਨ। ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ ASSERT_EQ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਬੇਸ ਅਤੇ ਸਬ-ਕਲਾਸ ਦੋਵੇਂ ਆਪੋ-ਆਪਣੇ ਆਪਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਮੈਮੋਰੀ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਨਿਰਧਾਰਤ ਅਤੇ ਮਿਟਾਉਂਦੇ ਹਨ। ਇਹ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਵੀ ਮੈਮੋਰੀ ਲੀਕ ਜਾਂ ਅਣਉਚਿਤ ਡੀਲਲੋਕੇਸ਼ਨ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਜੋ ਉਹਨਾਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜੋ ਡਾਇਨਾਮਿਕ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਸਾਫਟਵੇਅਰ ਵਿੱਚ ਜਿਨ੍ਹਾਂ ਨੂੰ ਉੱਚ ਗਤੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਕੁੱਲ ਮਿਲਾ ਕੇ, ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਦਿਖਾਉਂਦੀਆਂ ਹਨ ਕਿ ਕਿਵੇਂ C++ ਓਪਰੇਟਰ ਓਵਰਲੋਡਿੰਗ ਨੂੰ ਹੈਂਡਲ ਕਰਦੇ ਹਨ ਜਦੋਂ ਕਿ ਵਿਰਾਸਤੀ ਲੜੀ ਵਿੱਚ ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦੇ ਸਮੇਂ ਵਰਚੁਅਲ ਡਿਸਟ੍ਰਕਟਰਾਂ ਅਤੇ ਗਤੀਸ਼ੀਲ ਕਿਸਮ ਦੇ ਨਿਰਧਾਰਨ ਦੀ ਜ਼ਰੂਰਤ 'ਤੇ ਜ਼ੋਰ ਦਿੰਦੇ ਹਨ। VTable ਦੇ ਮਕੈਨਿਕਸ ਅਤੇ ਦੀ ਭੂਮਿਕਾ ਨੂੰ ਸਮਝਣਾ vptr ਦੱਸਦਾ ਹੈ ਕਿ ਉਚਿਤ ਕਿਉਂ ਹੈ ਮਿਟਾਓ ਓਪਰੇਟਰ ਨੂੰ ਰਨਟਾਈਮ 'ਤੇ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ, ਬੁਨਿਆਦੀ ਅਤੇ ਗੁੰਝਲਦਾਰ ਕਲਾਸ ਲੜੀ ਦੋਨਾਂ ਵਿੱਚ ਸਹੀ ਮੈਮੋਰੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ।
C++ ਵਿੱਚ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਅਤੇ ਮਿਟਾਓ ਆਪਰੇਟਰ ਚੋਣ
ਇਹ ਸਕ੍ਰਿਪਟ ਇਹ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ੁੱਧ C++ ਪਹੁੰਚ ਅਪਣਾਉਂਦੀ ਹੈ ਕਿ ਜਦੋਂ ਸਬ-ਕਲਾਸ ਇਸ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦੇ ਹਨ ਤਾਂ ਡਿਲੀਟ ਓਪਰੇਟਰ ਨੂੰ ਕਿਵੇਂ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ। ਅਸੀਂ ਕਲਾਸ ਅਤੇ ਉਪ-ਕਲਾਸਾਂ ਵਿੱਚ ਸਹੀ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਵਿਧੀ ਨਾਲ ਵਿਕਲਪਕ ਓਪਰੇਟਰ ਓਵਰਲੋਡਾਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ।
#include <iostream>#include <cstdlib>struct X {void* operator new(std::size_t size) {std::cout << "new X\n";return std::malloc(size);}void operator delete(void* ptr) {std::cout << "delete X\n";std::free(ptr);}virtual ~X() = default;};struct ArenaAllocatedX : public X {void* operator new(std::size_t size) {std::cout << "new ArenaAllocatedX\n";return std::malloc(size);}void operator delete(void* ptr) {std::cout << "delete ArenaAllocatedX\n";std::free(ptr);}};int main() {X* x1 = new X();delete x1;X* x2 = new ArenaAllocatedX();delete x2;return 0;}
ਓਪਰੇਟਰ ਡਿਲੀਟ ਲਈ C++ ਵਿੱਚ VTable ਖੋਜ
ਇਹ ਸਕ੍ਰਿਪਟ ਵਰਚੁਅਲ ਟੇਬਲ ਤਿਆਰ ਕਰਦੀ ਹੈ ਅਤੇ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਚੁਅਲ ਡਿਸਟ੍ਰਕਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਕਿ ਡਿਲੀਟ ਓਪਰੇਟਰ ਕਿਵੇਂ ਚੁਣੇ ਗਏ ਹਨ। G++ ਕੰਪਾਈਲਰ ਦੇ ਫਲੈਗ ਅਤੇ ਖਾਸ ਮੈਮੋਰੀ ਹੈਂਡਲਿੰਗ ਟੂਲ VTable ਦੇ ਢਾਂਚੇ ਨੂੰ ਦੇਖਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।
#include <iostream>#include <cstdlib>struct X {virtual ~X() { std::cout << "X destructor\n"; }static void operator delete(void* ptr) {std::cout << "delete X\n";std::free(ptr);}};struct ArenaAllocatedX : public X {virtual ~ArenaAllocatedX() { std::cout << "ArenaAllocatedX destructor\n"; }static void operator delete(void* ptr) {std::cout << "delete ArenaAllocatedX\n";std::free(ptr);}};int main() {X* x1 = new X();delete x1;X* x2 = new ArenaAllocatedX();delete x2;return 0;}
C++ ਵਿੱਚ ਮੈਮੋਰੀ ਹੈਂਡਲਿੰਗ ਲਈ ਯੂਨਿਟ ਟੈਸਟ
ਇਹ ਸਕ੍ਰਿਪਟ ਮੈਮੋਰੀ ਵੰਡ ਅਤੇ ਮਿਟਾਉਣ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਦੋਵਾਂ ਲਈ ਇਕਾਈ ਟੈਸਟ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ, ਜੋ ਕਿ C++ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਜਿਵੇਂ ਕਿ GoogleTest 'ਤੇ ਭਰੋਸਾ ਕਰਦੀ ਹੈ, ਇਹ ਗਾਰੰਟੀ ਦੇਣ ਲਈ ਕਿ ਓਪਰੇਟਰ ਮਿਟਾਉਣ ਦੇ ਢੰਗਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਬੁਲਾਇਆ ਗਿਆ ਹੈ।
#include <iostream>#include <gtest/gtest.h>struct X {void* operator new(std::size_t size) {return std::malloc(size);}void operator delete(void* ptr) {std::free(ptr);}virtual ~X() = default;};struct ArenaAllocatedX : public X {void* operator new(std::size_t size) {return std::malloc(size);}void operator delete(void* ptr) {std::free(ptr);}virtual ~ArenaAllocatedX() = default;};TEST(MemoryTest, DeleteX) {X* x = new X();delete x;ASSERT_EQ(1, 1); // Simplified check}TEST(MemoryTest, DeleteArenaAllocatedX) {X* x = new ArenaAllocatedX();delete x;ASSERT_EQ(1, 1); // Simplified check}int main(int argc, char argv) {::testing::InitGoogleTest(&argc, argv);return RUN_ALL_TESTS();}
ਬੁਨਿਆਦ ਤੋਂ ਪਰੇ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਸਮਝਣਾ
C++ ਵਿੱਚ, ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਮਿਟਾਓ ਜਦੋਂ ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਮਿਟਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਵਰਤਣ ਲਈ ਓਪਰੇਟਰ, ਖਾਸ ਕਰਕੇ ਸਬ-ਕਲਾਸਿੰਗ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ। ਅਜਿਹੀਆਂ ਸਥਿਤੀਆਂ ਵਿੱਚ, C++ ਰਨਟਾਈਮ 'ਤੇ ਵਸਤੂ ਦੀ ਅਸਲ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਡਾਇਨਾਮਿਕ ਟਾਈਪਿੰਗ ਦੀ ਧਾਰਨਾ ਨੂੰ ਨਿਯੁਕਤ ਕਰਦਾ ਹੈ। ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਜਦੋਂ ਇੱਕ ਬੇਸ ਕਲਾਸ ਰੈਫਰੈਂਸ ਇੱਕ ਡੈਰੀਵੇਡ ਕਲਾਸ ਦੇ ਇੱਕ ਆਬਜੈਕਟ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ, ਤਾਂ ਡੈਰੀਵੇਡ ਕਲਾਸ ਦੇ ਡਿਸਟ੍ਰਕਟਰ ਅਤੇ ਡਿਲੀਟ ਓਪਰੇਟਰ ਨੂੰ ਕਾਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਦਿੱਤੀ ਗਈ ਉਦਾਹਰਨ ਵਿੱਚ, ਬੇਸ ਕਲਾਸ ਐਕਸ ਅਤੇ ਸਬਕਲਾਸ ArenaAllocatedX ਦੇ ਆਪਣੇ ਸੰਸਕਰਣ ਬਣਾਓ ਨਵਾਂ ਅਤੇ ਮਿਟਾਓ ਆਪਰੇਟਰ ਜਦੋਂ ਇੱਕ ਵਸਤੂ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ C++ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਦੀ ਕਿਸਮ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ vptr (ਵਰਚੁਅਲ ਪੁਆਇੰਟਰ) ਤਕਨੀਕ। ਡਿਸਟ੍ਰਕਟਰ ਵਰਚੁਅਲ ਹੁੰਦਾ ਹੈ, ਇਸ ਗੱਲ ਦੀ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਮਿਟਾਉਣ ਦਾ ਕ੍ਰਮ ਸਬਕਲਾਸ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਗਤੀਸ਼ੀਲ ਕਿਸਮ ਲਈ ਸਹੀ ਮਿਟਾਉਣ ਦੀ ਕਾਰਵਾਈ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਇਹ ਵਿਧੀ ਮੈਮੋਰੀ ਲੀਕ ਨੂੰ ਰੋਕਣ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਉਪ-ਕਲਾਸ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਸਰੋਤ ਸਹੀ ਢੰਗ ਨਾਲ ਜਾਰੀ ਕੀਤੇ ਗਏ ਹਨ।
ਇਸ ਵਿਵਹਾਰ ਦਾ ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਇਹ ਹੈ ਕਿ C++ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸਟੋਰ ਨਹੀਂ ਕਰਦਾ ਹੈ ਨਵਾਂ ਅਤੇ ਮਿਟਾਓ ਵਿੱਚ ਆਪਰੇਟਰ VTable. ਇਸਦੀ ਬਜਾਏ, ਰਨਟਾਈਮ ਇਹ ਤਸਦੀਕ ਕਰਨ ਲਈ ਵਿਨਾਸ਼ਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਕਿ ਉਚਿਤ ਮਿਟਾਉਣ ਵਾਲੇ ਆਪਰੇਟਰ ਨੂੰ ਬੁਲਾਇਆ ਗਿਆ ਹੈ। ਇਸ ਵਿਧੀ ਤੋਂ ਬਿਨਾਂ, ਬੇਸ ਕਲਾਸ ਪੁਆਇੰਟਰ ਦੁਆਰਾ ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਨਸ਼ਟ ਕਰਨ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਅਧੂਰੀ ਮੈਮੋਰੀ ਡੀਲੋਕੇਸ਼ਨ ਹੋ ਜਾਵੇਗੀ, ਜਿਸ ਨਾਲ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਹ C++ ਵਿਰਾਸਤੀ ਲੜੀ ਵਿੱਚ ਵਰਚੁਅਲ ਵਿਨਾਸ਼ਕਾਰੀ ਦੀ ਮਹੱਤਤਾ 'ਤੇ ਜ਼ੋਰ ਦਿੰਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਕਸਟਮ ਮੈਮੋਰੀ ਵੰਡ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।
C++ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਬਾਰੇ ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ
- ਦਾ ਮਕਸਦ ਕੀ ਹੈ virtual destructor C++ ਵਿੱਚ?
- ਏ virtual destructor ਇਹ ਭਰੋਸਾ ਦਿਵਾਉਂਦਾ ਹੈ ਕਿ ਜਦੋਂ ਕਿਸੇ ਵਸਤੂ ਨੂੰ ਬੇਸ ਕਲਾਸ ਪੁਆਇੰਟਰ ਰਾਹੀਂ ਹਟਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਕਲਾਸ ਲਈ ਵਿਨਾਸ਼ਕਾਰ ਨੂੰ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਹੀ ਸਰੋਤ ਸਫਾਈ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
- ਕਰਦਾ ਹੈ delete ਓਪਰੇਟਰ ਨੂੰ VTable ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ?
- ਨਹੀਂ, ਦ delete ਓਪਰੇਟਰ ਨੂੰ VTable ਵਿੱਚ ਨਹੀਂ ਰੱਖਿਆ ਗਿਆ ਹੈ। ਵਿਨਾਸ਼ਕਾਰ ਵਰਚੁਅਲ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਉਚਿਤ ਹੈ delete ਓਪਰੇਟਰ ਨੂੰ ਵਸਤੂ ਦੀ ਗਤੀਸ਼ੀਲ ਕਿਸਮ ਦੇ ਅਧਾਰ ਤੇ ਚੁਣਿਆ ਜਾਂਦਾ ਹੈ।
- C++ ਇਹ ਕਿਵੇਂ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ delete ਕਾਲ ਕਰਨ ਲਈ ਆਪਰੇਟਰ?
- C++ ਰਾਹੀਂ ਡਾਇਨਾਮਿਕ ਟਾਈਪਿੰਗ ਨੂੰ ਰੁਜ਼ਗਾਰ ਦਿੰਦਾ ਹੈ vptr (ਵਰਚੁਅਲ ਪੁਆਇੰਟਰ) ਉਚਿਤ ਦੀ ਚੋਣ ਕਰਨ ਲਈ delete ਮਿਟਾਏ ਜਾ ਰਹੇ ਵਸਤੂ ਦੀ ਕਿਸਮ 'ਤੇ ਆਧਾਰਿਤ ਓਪਰੇਟਰ।
- ਕਿਉਂ ਹੈ vptr ਸਬਕਲਾਸ ਮਿਟਾਉਣ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੈ?
- ਦ vptr VTable ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਵਰਚੁਅਲ ਫੰਕਸ਼ਨਾਂ ਲਈ ਪਤੇ ਹੁੰਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਵਿਨਾਸ਼ਕਾਰੀ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਦਾ ਉਚਿਤ ਸੰਸਕਰਣ delete ਜਦੋਂ ਇੱਕ ਸਬਕਲਾਸ ਆਬਜੈਕਟ ਨੂੰ ਮਿਟਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।
- ਕੀ ਮੈਂ ਦੋਵਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦਾ ਹਾਂ operator new ਅਤੇ operator delete C++ ਵਿੱਚ?
- ਓਵਰਰਾਈਡਿੰਗ operator new ਅਤੇ operator delete ਕਿਸੇ ਵੀ ਕਲਾਸ ਵਿੱਚ ਤੁਹਾਨੂੰ ਇਹ ਬਦਲਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਕਿ ਕਿਵੇਂ ਮੈਮੋਰੀ ਨੂੰ ਨਿਰਧਾਰਤ ਅਤੇ ਮੁਕਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਨਾਲ ਉਦਾਹਰਨ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ X ਅਤੇ ArenaAllocatedX.
ਸਿੱਟਾ:
ਉਚਿਤ ਦੀ ਚੋਣ ਮਿਟਾਓ C++ ਵਿੱਚ ਆਪਰੇਟਰ ਨੂੰ ਇਹ ਸਮਝਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਕਿਵੇਂ ਵਰਚੁਅਲ ਡਿਸਟ੍ਰਕਟਰ ਅਤੇ ਡਾਇਨਾਮਿਕ ਕਿਸਮਾਂ ਆਪਸ ਵਿੱਚ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਪਾਉਂਦੀਆਂ ਹਨ। ਜਦੋਂ ਇੱਕ ਸਬ-ਕਲਾਸ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਦਾ ਹੈ, ਤਾਂ ਕੰਪਾਈਲਰ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਆਬਜੈਕਟ ਦੇ ਵਿਨਾਸ਼ ਲਈ ਉਚਿਤ ਓਪਰੇਟਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਇਹ ਵਿਧੀ ਮੈਮੋਰੀ ਲੀਕ ਤੋਂ ਬਚਾਉਂਦੀ ਹੈ ਅਤੇ ਗਰੰਟੀ ਦਿੰਦੀ ਹੈ ਕਿ ਸਬ-ਕਲਾਸ-ਵਿਸ਼ੇਸ਼ ਸਰੋਤਾਂ ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਸਾਫ਼ ਕੀਤਾ ਗਿਆ ਹੈ। ਉਦਾਹਰਣਾਂ ਅਤੇ VTable ਪੜਚੋਲ ਦੁਆਰਾ, ਕੋਰਸ C++ ਵਿਰਾਸਤ ਦੇ ਇਸ ਨਾਜ਼ੁਕ ਹਿੱਸੇ ਅਤੇ ਭਾਸ਼ਾ ਮੈਮੋਰੀ ਡੀਲਲੋਕੇਸ਼ਨ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੀ ਹੈ ਬਾਰੇ ਚਾਨਣਾ ਪਾਉਂਦੀ ਹੈ।
ਸਰੋਤ ਅਤੇ ਹਵਾਲੇ
- ਦੀ ਚੋਣ ਬਾਰੇ ਸਮੱਗਰੀ ਮਿਟਾਓ C++ ਵਿੱਚ ਆਪਰੇਟਰ ਅਧਿਕਾਰੀ ਵਿੱਚ ਮਿਲੀ ਜਾਣਕਾਰੀ ਦੇ ਆਧਾਰ 'ਤੇ ਸਨ C++ ਹਵਾਲਾ ਦਸਤਾਵੇਜ਼ .
- ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਸਰੋਤਾਂ ਦੁਆਰਾ ਕੰਪਾਈਲਰ ਵਿਵਹਾਰ ਅਤੇ VTable ਪੀੜ੍ਹੀ ਦੇ ਵੇਰਵਿਆਂ ਦੀ ਖੋਜ ਕੀਤੀ ਗਈ ਸੀ GCC ਦਸਤਾਵੇਜ਼ .
- ਉਦਾਹਰਨ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਾਂਚ ਕੀਤੀ ਗਈ ਅਤੇ ਵਿਜ਼ੂਅਲ ਕੀਤਾ ਗਿਆ ਕੰਪਾਈਲਰ ਐਕਸਪਲੋਰਰ (ਗੌਡਬੋਲਟ) ਟੂਲ, ਜੋ ਕਿ ਵੱਖ-ਵੱਖ ਕੰਪਾਈਲਰਾਂ ਵਿੱਚ ਰੀਅਲ-ਟਾਈਮ ਕੰਪਾਈਲੇਸ਼ਨ ਵਿਵਹਾਰ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ।