C ++ ਵਿਚ ਡਾਇਨਾਮਿਕ ਫੰਕਸ਼ਨ

Alice Dupont

ਸੋਮਵਾਰ, 17 ਫ਼ਰਵਰੀ 2025 3:42:21 ਬਾ.ਦੁ.

ਡਾਇਨੈਮਿਕ ਕਾਰਡ ਅਪਗ੍ਰੇਡਾਂ ਲਈ ਮਾਸਟਰਿੰਗ ਫੰਕਸ਼ਨ ਤਬਦੀਲੀ

ਕਾਰਡ ਗੇਮ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜਿੱਥੇ ਹਰ ਕਾਰਡ ਨਵੀਂ ਯੋਗਤਾਵਾਂ ਨਾਲ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਵਿਕਸਤ ਹੋ ਸਕਦਾ ਹੈ. 🎴 ਤੁਸੀਂ ਰੰਨਟਾਈਮ ਤੇ ਇੱਕ ਕਾਰਡ ਦੇ ਪਲੇ () ਕਾਰਡ ਦੇ ਪਲੇ ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਪ੍ਰਭਾਵਾਂ ਨੂੰ "ਮਿੱਲ ਇੱਕ ਕਾਰਡ" ਜਾਂ "ਇਸ ਨੂੰ ਦੋ ਵਾਰ ਖੇਡੋ". ਇਹ ਇੱਕ ਬਹੁਤ ਹੀ ਲਚਕਦਾਰ ਪ੍ਰਣਾਲੀ ਤਿਆਰ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਕਾਰਡ ਨਿਰਵਿਘਨ ਅਪਗ੍ਰੇਡ ਕਰਨ ਲਈ ਅਨੁਕੂਲ ਹੁੰਦੇ ਹਨ.

ਰਵਾਇਤੀ ਤੌਰ ਤੇ, ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੋਧਣਾ ਆਰਜੀ ਤੌਰ 'ਤੇ ਸੀ ++ ਇਸ ਦੇ ਸਥਿਰ ਸੁਭਾਅ ਦੇ ਕਾਰਨ ਘ੍ਰਿਣਾਯੋਗ ਹੈ. ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਸ਼ਾਸਨਾਂ ਨਾਲ ਭਾਸ਼ਾਵਾਂ ਦੇ ਉਲਟ, ਸੀ +++ ਇੱਕ structure ਾਂਚਾਗਤ ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਵੇਂ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ, ਲੇਮਾਂਡਸ, ਜਾਂ ਐਸਟੀਡੀ :: ਫੰਕਸ਼ਨ. ਸਹੀ method ੰਗ ਦੀ ਚੋਣ ਕੁਸ਼ਲਤਾ ਅਤੇ ਨਿਰੰਤਰਤਾ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ.

ਇਕ ਚੁਣੌਤੀ ਅਸਲੀ ਫੰਕਸ਼ਨ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰ ਰਹੀ ਹੈ ਜਦੋਂਕਿ ਕੋਡ ਦੀ ਭਾਰੀ ਮਾਤਰਾ ਨੂੰ ਮੁੜ ਲਿਖੇ ਬਿਨਾਂ ਅਪਗ੍ਰੇਡ ਕੀਤੇ ਗਏ. ਤੁਹਾਨੂੰ ਮੌਜੂਦਾ ਨਾਟਕ () ਫੰਕਸ਼ਨ ਨੂੰ ਸਮੇਟਣ ਅਤੇ ਇਸ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਲਾਗੂ ਕੀਤੇ ਅਪਗ੍ਰੇਡਾਂ ਦੇ ਅਧਾਰ ਤੇ ਵਧਾਉਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਸ ਨੂੰ ਸਜਾਉਣ ਵਾਂਗ ਸੋਚੋ - ਹਰ ਪਰਤ ਨੂੰ ਪੂਰੇ ਕੇਕ ਦੀ ਥਾਂ ਲੈ ਕੇ ਇਕ ਅਨੌਖਾ ਸੁਆਦ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ! 🎂

ਇਸ ਲੇਖ ਵਿਚ, ਅਸੀਂ ਪੜਚੋਲ ਕਰਾਂਗੇ ਕਿ C ++ ਵਿਚ ਗਤੀਸ਼ੀਲਤਾ ਨੂੰ ਆਰਜੀ ਤੌਰ 'ਤੇ ਲਾਗੂ ਕਰਨਾ ਹੈ. ਅਸੀਂ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰਜ਼ ਅਤੇ ਐਸਟੀਡੀ ਵਰਗੇ ਰਣਨੀਤੀਆਂ ਨੂੰ ਵੇਖਾਂਗੇ :: ਉਨ੍ਹਾਂ ਦੇ ਟ੍ਰੇਡ-ਆਫ ਬਾਰੇ ਵਿਚਾਰ ਵਟਾਂਦਰੇ ਦੌਰਾਨ ਫੰਕਸ਼ਨ. ਭਾਵੇਂ ਤੁਸੀਂ ਇੱਕ ਮੌਜੂਦਾ ਸਿਸਟਮ ਨੂੰ ਸੁਧਾਰੀ ਜਾਂ ਤੁਸੀਂ ਨਵੇਂ ਹੋ ਜਾਂ ਇੱਕ ਮੌਜੂਦਾ ਸਿਸਟਮ ਨੂੰ ਸੁਧਾਰੀ ਕਰ ਰਹੇ ਹੋ, ਇਹ ਤਕਨੀਕ ਤੁਹਾਨੂੰ ਵਧੇਰੇ ਲਚਕਦਾਰ ਅਤੇ ਸਕੇਲੇਬਲ ਗੇਮ ਡਿਜ਼ਾਈਨ ਬਣਾਉਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰੇਗੀ.

ਕਮਾਂਡ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਣ
std::function<void()>	ਇੱਕ ਲਚਕਦਾਰ ਫੰਕਸ਼ਨ ਰੈਪਰ ਰਨਟਾਈਮ ਤੇ ਗਤੀਸ਼ੀਲ ਕਾਰਜ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਖੇਡ ਨੂੰ ਆਰਜੀ ਤੌਰ ਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਸਟੋਰ ਅਤੇ ਸੰਸ਼ੋਧਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ.
typedef void (*PlayFunc)();	ਇੱਕ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ ਦੀ ਕਿਸਮ ਨੂੰ ਪ੍ਰਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ, ਪਲੇ ਫੰਕਸ਼ਨ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਨੂੰ ਸਮਰੱਥ ਕਰਨਾ.
auto oldPlay = card.PlayFunction;	ਇਸ ਨੂੰ ਬਦਲਣ ਤੋਂ ਪਹਿਲਾਂ ਅਸਲ ਫੰਕਸ਼ਨ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨਾ ਕਿ ਪਿਛਲਾ ਵਿਵਹਾਰ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਵਧਾਇਆ ਜਾ ਸਕਦਾ ਹੈ.
card.PlayFunction = [=]() { oldPlay(); MillCard(); };	ਅਸਲ ਕਾਰਜ ਨੂੰ ਸਮੇਟਣ ਅਤੇ ਗਤੀਸ਼ੀਲ ਪ੍ਰਭਾਵਾਂ ਲਈ ਇੱਕ ਲਾਂਬਡਾ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ.
virtual void Play()	ਰੰਨਟਾਈਮ ਪੌਲੀਮੋਰਫਿਜ਼ਮ ਲਈ ਬਣੀ ਹੋਈਆਂ ਕਲਾਸਾਂ ਵਿਚ ਅਣਡਿੱਠਾ ਵਾਲੀਆਂ ਕਲਾਸਾਂ ਵਿਚ ਅਣਡਿੱਠਾ ਕਰਨ ਲਈ ਇਕ ਵਰਚੁਅਲ ਵਿਧੀ ਨੂੰ ਪਰਿਭਾਸ਼ਤ ਕਰਦਾ ਹੈ.
class UpgradedCard : public Card	ਇੱਕ ਸਬ-ਕਲਾਸ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜੋ ਪਲੇ ਕਲਾਸ ਨੂੰ ਸਿੱਧਾ ਪ੍ਰਸਾਰਿਤ ਕੀਤੇ ਬਿਨਾਂ ਖੇਡ ਦੇ ਵਿਵਹਾਰ ਦਾ ਵਿਵਹਾਰ ਵਧਾਉਂਦਾ ਹੈ.
delete myCard;	ਮੈਮੋਰੀ ਲੀਕ ਨੂੰ ਰੋਕਣ ਲਈ ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ ਮੈਮੋਰੀ ਨੂੰ ਆਰਜੀ ਤੌਰ ਤੇ ਬਣਾਈ ਗਈ ਇਕਾਈ ਲਈ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ.
std::cout << "Milling a card\n";	ਕੰਸੋਲ ਤੇ ਟੈਕਸਟ ਆਉਟਪੁੱਟ, ਡੀਬੱਗ ਕਰਨ ਅਤੇ ਫੰਕਸ਼ਨ ਐਗਜ਼ੀਕਿ .ਸ਼ਨ ਆਰਡਰ ਨੂੰ ਵੇਖਣਾ.
PlayFunc playFunction = &BasePlay;	ਇੱਕ ਕਾਰਜ ਨੂੰ ਇੱਕ ਮੌਜੂਦਾ ਫੰਕਸ਼ਨ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ, ਲਚਕਦਾਰ ਰੰਨਟਾਈਮ ਮੁੜ ਸਪੁਰਦਗੀ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ.

ਇੱਕ ਕਾਰਡ ਗੇਮ ਵਿੱਚ ਡਾਇਨੈਮਿਕ ਫੰਕਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਰਨਟਾਈਮ 'ਤੇ ਪਲੇ () ਪਲੇਅ () ਫੰਕਸ਼ਨ ਵਿਚ ਸੋਧਣ ਨਾਲ ਗੇਮਪਲੇ ਲਈ ਵਧੇਰੇ ਲਚਕਤਾ ਲਈ ਗਤੀਸ਼ੀਲਤਾ ਨੂੰ ਸੋਧਣਾ. ਹਰੇਕ ਅਪਗ੍ਰੇਡ ਲਈ ਖੇਡ ਕਾਰਜ ਦੇ ਵੱਖਰੇ ਸੰਸਕਰਣ ਲਿਖਣ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ, ਲਾਂਬਦਾਸ, ਅਤੇ std :: ਕਾਰਜ ਆਰਜੀ ਤੌਰ ਤੇ ਕਾਰਡ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਕਰਨ ਲਈ. ਇਹ ਪਹੁੰਚ ਅਪਗ੍ਰੇਡਾਂ ਨੂੰ ਅਪਗ੍ਰੇਡ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਯੋਗ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ "ਬੈਂਕ ਨੂੰ ਮਿੱਲ ਕਰੋ" ਜਾਂ "ਦੋ ਵਾਰ ਦੋ ਵਾਰ" ਤੋਂ ਬਿਨਾਂ ਮੁੜ ਲਿਖਾਓ. ਇੱਕ ਸੰਗ੍ਰਿਹਿੰਗ ਕਾਰਡ ਗੇਮ ਖੇਡਣ ਦੀ ਕਲਪਨਾ ਕਰੋ ਜਿੱਥੇ ਤੁਸੀਂ ਕਾਰਡ ਮਿਡ-ਗੇਮ ਵਿੱਚ ਇੱਕ ਯੋਗਤਾ ਨੱਥੀ ਕਰਦੇ ਹੋ, ਇਸਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਤੁਰੰਤ ਬਦਲਦੇ ਹੋ! 🎴

ਵਰਤੀ ਗਈ ਮੁੱਖ ਤਕਨੀਕਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਫੰਕਸ਼ਨ ਰੈਪਰ ਐਸਟੀਡੀ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤਾ :: ਕਾਰਜ. ਇਹ ਸਾਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਸਟੋਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇਸ ਨੂੰ ਵਾਧੂ ਵਿਵਹਾਰਾਂ ਨਾਲ ਸੋਧਦਾ ਹੈ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਜਦੋਂ ਕੋਈ ਅਪਗ੍ਰੇਡ ਲਾਗੂ ਹੁੰਦਾ ਹੈ, ਅਸੀਂ ਪਿਛਲੇ ਪਲੇ () ਫੰਕਸ਼ਨ ਨੂੰ ਫੜ ਲੈਂਦੇ ਹਾਂ ਅਤੇ ਇਸ ਨੂੰ ਨਵੇਂ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਲਪੇਟਦੇ ਹਾਂ ਜੋ ਇਸਦੇ ਵਿਵਹਾਰ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ. ਇਹ ਇੱਕ ਗੇਮ ਵਿੱਚ ਰਣਨੀਤੀ ਦੀ ਵਾਧੂ ਪਰਤ ਨੂੰ ਇੱਕ ਆਰਪੀਜੀ ਵਿੱਚ ਇੱਕ ਪਾਤਰ ਤੇ ਸਟੈਕਿੰਗ ਬੱਫਾਂ ਵਾਂਗ ਹੈ ਜਿਵੇਂ ਕਿ ਸਟੈਕਿੰਗ ਬੱਫਾਂ ਦੀ ਤਰ੍ਹਾਂ! 🛡️

ਇਕ ਹੋਰ ਤਰੀਕਾ ਜੋ ਅਸੀਂ ਖੋਜਿਆ ਹੈ ਉਹ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੈ. ਫੰਕਸ਼ਨ ਪਿਕ ਕਰਨ ਵਾਲੇ ਸਾਨੂੰ ਇਹ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ ਕਿ ਰਨਟਾਈਮ ਤੇ ਕਿਹੜਾ ਫੰਕਸ਼ਨ ਉਨ੍ਹਾਂ ਨੂੰ ਆਦਰਸ਼ ਬਣਾ ਰਿਹਾ ਹੈ ਜਿੱਥੇ ਕਾਰਗੁਜ਼ਾਰੀ ਨਾਜ਼ੁਕ ਹੈ. ਜਦੋਂ ਉਹ ਲਚਕਤਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਉਹ ਐਸਟੀਡੀ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਸਖਤ ਹੋ ਸਕਦੇ ਹਨ :: ਸਮਾਗਮ, ਖ਼ਾਸਕਰ ਜਦੋਂ ਸਥਾਨਕ ਵੇਰੀਏਬਲ ਕੈਪਚਰ ਕਰਦੇ ਸਮੇਂ. ਹਾਲਾਂਕਿ, ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ ਪ੍ਰਦਰਸ਼ਨ-ਸੰਵੇਦਨਸ਼ੀਲ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੁੰਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਰੀਅਲ-ਟਾਈਮ ਕਾਰਡ ਨਾਲ ਗੱਲਬਾਤ ਜਾਂ ਕਾਰਡ ਗੇਮ ਵਿੱਚ ਏਆਈ ਫੈਸਲਾ ਲੈਣ ਵਾਲੇ ਏਆਈ ਫੈਸਲਾ ਲੈਣ ਵਾਲੇ.

ਅੰਤ ਵਿੱਚ, ਵਰਤ ਕੇ ਇੱਕ ਆਬਜੈਕਟ-ਅਧਾਰਤ ਪਹੁੰਚ ਵਿਰਾਸਤ ਅਤੇ ਵਿਧੀ ਓਵਰਰਾਈਡਿੰਗ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ. ਇਹ ਵਿਧੀ ਸਾਨੂੰ ਮਾਹਰ ਕਲਾਸਾਂ ਨੂੰ ਬਣਾ ਕੇ ਪਲੇ () ਫੰਕਸ਼ਨ ਨੂੰ ਵਧਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜੋ ਇਸਦੇ ਵਿਵਹਾਰ ਨੂੰ ਸੰਸ਼ੋਧਿਤ ਕਰਦੀ ਹੈ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਵਾਧੂ ਪ੍ਰਭਾਵ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਬੇਸ ਕਾਰਡ ਕਲਾਸ ਅਤੇ ਓਵਰਰਾਈਡ ਪਲੇ () ਓਵਰਰਾਈਡ ਪਲੇ () ਤੋਂ ਓਵਰਰਾਈਡ ਪਲੇ () ਤੋਂ ਵੱਧ ਖੇਡਣ ਤੋਂ ਇਲਾਵਾ) ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ. ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਗੇਮ ਮਕੈਨਿਕਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਵੇਲੇ ਇਹ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਖਾਸ ਕਾਰਡ ਕਿਸਮਾਂ ਲਈ ਵਿਲੱਖਣ ਵਿਵਹਾਰਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਇਹਨਾਂ ਤਕਨੀਕਾਂ ਨੂੰ ਜੋੜ ਕੇ, ਡਿਵੈਲਪਰ ਇੱਕ ਬਹੁਤ ਹੀ ਮਾਡਯੂਲਰ ਅਤੇ ਐਕਸਟੈਂਸੀਬਲ ਕਾਰਡ ਗੇਮ ਸਿਸਟਮ ਬਣਾ ਸਕਦੇ ਹਨ ਜੋ ਨਿਰਵਿਘਨਤਾ ਨਾਲ ਗਤੀਸ਼ੀਲ ਅਪਗ੍ਰੇਡਾਂ ਲਈ ਸਹਿਯੋਗੀ ਹੋ ਸਕਦੇ ਹਨ.

C ++ ਕਾਰਡ ਗੇਮ ਵਿੱਚ ਰਨਟਾਈਮ ਤੇ ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਸੋਧਣਾ

ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ, ਲੇਮਾਂਡਾਸ ਦੀ ਵਰਤੋਂ ਕਰਦਿਆਂ, ਅਤੇ ਐਸਟੀਡੀ :: ਗਤੀਸ਼ੀਲ ਵਿਵਹਾਰ ਨੂੰ ਸੋਧਣ ਲਈ ਸੀ ++ ਵਿਚ ਫੰਕਸ਼ਨ

#include <iostream>
#include <functional>
class Card {
public:
    std::function<void()> PlayFunction;
    Card() {
        PlayFunction = [&]() { std::cout << "Playing base card\n"; };
    }
    void Play() { PlayFunction(); }
};
void MillCard() { std::cout << "Milling a card\n"; }
void UpgradeWithMill(Card &card) {
    auto oldPlay = card.PlayFunction;
    card.PlayFunction = [=]() { oldPlay(); MillCard(); };
}
int main() {
    Card myCard;
    UpgradeWithMill(myCard);
    myCard.Play();
    return 0;
}

ਵਿੱਤੀ ਤੌਰ ਤੇ C ++ ਵਿੱਚ ਇੱਕ ਵਿਧੀ ਨੂੰ ਆਰਜੀ ਤੌਰ ਤੇ ਤਬਦੀਲ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਰੰਨਟਾਈਮ ਸੋਧਾਂ ਵਿੱਚ ਬਿਹਤਰ ਨਿਯੰਤਰਣ ਲਈ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗੂ ਕਰਨਾ

#include <iostream>
typedef void (*PlayFunc)();
void BasePlay() { std::cout << "Base play function\n"; }
void PlayTwice() {
    std::cout << "Playing twice!\n";
    BasePlay();
    BasePlay();
}
int main() {
    PlayFunc playFunction = &BasePlay;
    playFunction();
    playFunction = &PlayTwice;
    playFunction();
    return 0;
}

ਵਧੇਰੇ ਐਕਸਟੈਂਸੀਬਲ ਕਾਰਡ ਅਪਗ੍ਰੇਡਾਂ ਲਈ ਕਲਾਸ-ਅਧਾਰਤ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਬੀਸਰ ਅਤੇ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਬਜੈਕਟ-ਅਧਾਰਿਤ method ੰਗ

#include <iostream>
class Card {
public:
    virtual void Play() { std::cout << "Playing base card\n"; }
};
class UpgradedCard : public Card {
public:
    void Play() override {
        Card::Play();
        std::cout << "Additional effect triggered!\n";
    }
};
int main() {
    Card* myCard = new UpgradedCard();
    myCard->Play();
    delete myCard;
    return 0;
}

ਸਜਾਵਟ ਅਤੇ ਮਿਡਲਵੇਅਰ ਨਾਲ ਰਨਟਾਈਮ ਫੰਕਸ਼ਨ ਬਦਲੋ

ਕਾਰਜਾਂ ਨੂੰ ਸੋਧਣ ਦਾ ਇਕ ਹੋਰ ਸ਼ਕਤੀਸ਼ਾਲੀ way ੰਗ ਹੈ C ++ ਵਿਚ ਆਰਜੀ ਤੌਰ ਤੇ ਵਰਤਣਾ ਸਜਾਵਟ ਪੈਟਰਨ. ਇਹ ਵਿਧੀ ਤੁਹਾਨੂੰ ਕੋਰ ਤਰਕ ਦੀ ਬਰੈਕਟ ਰੱਖਦੇ ਹੋਏ ਵਾਧੂ ਵਿਵਹਾਰਾਂ ਨਾਲ ਇੱਕ ਮੌਜੂਦਾ ਕਾਰਜ ਨੂੰ ਸਮੇਟਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ. ਪਲੇਅ () ਫੰਕਸ਼ਨ ਨੂੰ ਸਿੱਧਾ ਬਦਲਣ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਇਕ ਰੋਲ-ਖੇਡਣ ਵਾਲੀ ਖੇਡ ਵਿਚ ਬੱਫਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਸਮਾਨ ਸੋਧ ਦੀ ਚੇਨ ਬਣਾਉਂਦੇ ਹਾਂ. ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਅਧਾਰ ਕਾਰਡ ਹੈ ਜੋ ਨੁਕਸਾਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਇੱਕ "ਬਰਨ" ਪ੍ਰਭਾਵ ਸ਼ਾਮਲ ਕਰਦੇ ਹੋ - ਹਰ ਵਾਰ ਜਦੋਂ ਕਾਰਡ ਦੇ ਨਾਲ ਵੀ ਦੁਸ਼ਮਣ ਵੀ ਨੁਕਸਾਨ ਹੁੰਦਾ ਹੈ. 🔥

ਮਿਡਲਵੇਅਰ-ਸ਼ੈਲੀ ਫੰਕਸ਼ਨ ਲਪੇਟਣਾ ਵੈਬ ਡਿਵੈਲਪਮੈਂਟ ਦੁਆਰਾ ਪ੍ਰੇਰਿਤ ਇਕ ਹੋਰ ਪਹੁੰਚ ਹੈ ਪਰ ਗੇਮ ਮਕੈਨਿਕਸ ਲਈ ਲਾਗੂ ਹੁੰਦਾ ਹੈ. ਇੱਥੇ, ਹਰ ਪ੍ਰਭਾਵ ਇੱਕ ਪਰਤ ਦੇ ਰੂਪ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਮੁੱਖ ਕਾਰਜ ਤੋਂ ਪਹਿਲਾਂ ਜਾਂ ਬਾਅਦ ਵਿੱਚ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ. ਦੀ ਵਰਤੋਂ std: vort ਮਲਟੀਪਲ ਫੰਕਸ਼ਨ ਰੈਪਰਸ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਮਲਟੀਪਲ ਅਪਗ੍ਰੇਡ ਗਤੀਸ਼ੀਲਤਾ ਨੂੰ ਕੱ ress ਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਇੱਕ ਕਾਰਡ ਦੋਨੋ "ਦੋ ਵਾਰ ਖੇਡਦਾ" ਅਤੇ "ਮਿੱਲ ਇਨ ਕਾਰਡ" ਕਾਬਲੀਅਤਾਂ ਨੂੰ ਪ੍ਰਕਾਸ਼ਤ ਕੀਤੇ ਬਿਨਾਂ ਯੋਗਤਾਵਾਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ. ਇਹ ਇੱਕ ਖੇਡ ਵਿੱਚ ਮਲਟੀਪਲ ਪਾਵਰ-ਅਪਸ ਨੂੰ ਸਵੀਕਾਰਨ ਦੇ ਸਮਾਨ ਹੈ, ਜਿੱਥੇ ਹਰੇਕ ਇਨਹਾਂਸਮੈਂਟ ਨਵੀਂ ਯੋਗਤਾਵਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ.

ਅੰਤ ਵਿੱਚ, ਵਿਚਾਰ ਕਰਨਾ ਇਵੈਂਟ-ਸੰਚਾਲਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਰੰਨਟਾਈਮ ਸੋਧਾਂ ਨੂੰ ਅੱਗੇ ਵਧਾ ਸਕਦਾ ਹੈ. ਇੱਕ ਅਬਜ਼ਰਵਰ ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਕਾਰਡ ਪ੍ਰਭਾਵ ਪ੍ਰਭਾਵ ਪਾ ਸਕਦੇ ਹਨ ਅਤੇ ਗਤੀਸ਼ੀਲ ਅਤੇ ਟਰਿੱਗਰਾਂ ਨੂੰ ਜਵਾਬ ਦੇ ਸਕਦੇ ਹਨ. ਇਹ ਲਾਭਦਾਇਕ ਸੰਵਾਦਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵੇਲੇ, ਜਿਵੇਂ ਕਿ ਖਾਸ ਸ਼ਰਤਾਂ ਦੇ ਅਧਾਰ ਤੇ ਮਲਟੀਪਲ ਪ੍ਰਭਾਵਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨਾ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ. ਉਦਾਹਰਣ ਦੇ ਲਈ, ਜੇ ਕੁਝ ਸਥਿਤੀਆਂ ਵਿੱਚ ਖੇਡਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇੱਕ ਕਾਰਡ ਵੱਖਰਾ ਪ੍ਰਭਾਵ ਪ੍ਰਾਪਤ ਹੁੰਦਾ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਵਾਧੂ ਕਾਰਡ ਬਣਾਉਣਾ ਜੇ ਕੋਈ ਹੋਰ ਕਾਰਡ ਪਹਿਲਾਂ ਵਾਰੀ ਵਿੱਚ ਖੇਡਿਆ ਜਾਂਦਾ ਸੀ. ਇਹ ਤਕਨੀਕ C ++ ਤੋਂ ਵਧੇਰੇ ਲਚਕਦਾਰ ਅਤੇ ਸਕੇਲੇਬਲ ਵਿੱਚ ਫੰਕਸ਼ਨ ਨੂੰ ਬਦਲ ਦਿੰਦੀ ਹੈ. 🎮

C ++ ਵਿਚ ਰੰਨਟਾਈਮ ਫੰਕਸ਼ਨ ਰਿਪਲੇਸਮੈਂਟ ਬਾਰੇ ਆਮ ਪ੍ਰਸ਼ਨ

C ++ ਵਿੱਚ ਰਨਟਾਈਮ ਵਿਖੇ ਇੱਕ ਕਾਰਜ ਨੂੰ ਤਬਦੀਲ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ?
ਦੀ ਵਰਤੋਂ std::function ਪੜ੍ਹਨਯੋਗਤਾ ਬਣਾਈ ਰੱਖਣ ਦੌਰਾਨ ਲਚਕਦਾਰਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ. ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਕਾਰਜਾਂ ਲਈ ਵੀ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦੇ ਹਨ.
ਇਸ ਨੂੰ ਸੋਧਣ ਵੇਲੇ ਮੈਂ ਅਸਲ ਕਾਰਜ ਨੂੰ ਕਿਵੇਂ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹਾਂ?
ਅਸਲ ਕਾਰਜ ਨੂੰ ਇਸ ਨੂੰ ਬਦਲਣ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰੋ, ਫਿਰ ਇਸ ਨੂੰ ਲਮਬੈਡ ਰੈਪਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਵੇਂ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਕਾਲ ਕਰੋ.
ਕੀ ਮੈਂ ਇਕੱਠੇ ਕਈ ਫੰਕਸ਼ਨ ਦੇ ਬਦਲਾਵਾਂ ਨੂੰ ਇਕੱਠੇ ਕਰ ਸਕਦਾ ਹਾਂ?
ਹਾਂ! ਦੀ ਵਰਤੋਂ std::vector ਫੰਕਸ਼ਨ ਰੈਪਰਸ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਮਲਟੀਪਲ ਅਪਗ੍ਰੇਡ ਗਤੀਸ਼ੀਲ ਨੂੰ ਸਟੈਕਿੰਗ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ.
ਰਨਟਾਈਮ ਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੋਧਣ ਵੇਲੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਵਿਚਾਰ ਕੀ ਹੁੰਦੇ ਹਨ?
ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ ਤੇਜ਼ ਪਰ ਘੱਟ ਲਚਕਦਾਰ ਹੁੰਦੇ ਹਨ. std::function ਮਾਮੂਲੀ ਓਵਰਹੈੱਡ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ ਪਰ ਸੰਭਾਲਣ ਨੂੰ ਸੁਧਾਰਦਾ ਹੈ.
ਇਹ ਕਿਵੇਂ ਸੰਸ਼ੋਧਨ ਕਰਨ ਵਾਲੇ ਵਤੀਰੇ ਲਈ ਵਿਰਾਸਤ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਦਾ ਹੈ?
ਵਿਰਾਸਤ ਪਹਿਲਾਂ ਹੀ ਪਰਿਭਾਸ਼ਿਤ ਵਿਵਹਾਰ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਲਈ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਗਤੀਸ਼ੀਲ, ਰੰਨਟਾਈਮ ਸੋਧਾਂ ਲਈ ਫੰਕਸ਼ਨ ਤਬਦੀਲੀ ਬਿਹਤਰ ਹੁੰਦੀ ਹੈ.

ਡਾਇਨਾਮਿਕ ਫੰਕਸ਼ਨ ਤਬਦੀਲੀ 'ਤੇ ਅੰਤਮ ਵਿਚਾਰ

ਇੱਕ ਗੇਮ ਸਿਸਟਮ ਨੂੰ ਲਚਕਤਾ ਜੋੜਨ ਲਈ C ++ ਵਿੱਚ ਰੰਨਟਾਈਮ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਕਨੀਕ ਹੈ. ਲੇਵਰੇਜਿੰਗ ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਰ, ਲਾਂਦਾ ਸਮੀਕਰਨ, ਅਤੇ ਐਸਟੀਡੀ ਦੁਆਰਾ :: ਸਮਾਗਮ, ਡਿਵੈਲਪਰ ਕਾਰਡ ਵਿਵਹਾਰ ਨੂੰ ਗਤੀਸ਼ੀਲ ਤੌਰ ਤੇ ਸੰਸ਼ੋਧਿਤ ਕਰ ਸਕਦੇ ਹਨ. ਇਹ ਵਿਧੀ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ ਕਿ ਖੇਡ ਮਕੈਨਿਕ ਬਿਨਾਂ ਸੰਭਾਵਤ ਤੌਰ ਤੇ ਦੁਬਾਰਾ ਲਿਖਾਈ ਜਾਂ ਗੁੰਝਲਦਾਰ ਕਲਾਸ ਦੀਆਂ ਲੜੀਆਂ ਦੀ ਜ਼ਰੂਰਤ ਤੋਂ ਬਿਨਾਂ ਅਨੁਕੂਲ ਰਹਿੰਦੀ ਹੈ.

ਕਾਰਡ ਗੇਮਜ਼ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਪਹੁੰਚ ਏਆਈ ਵਿਵਹਾਰ ਵਿੱਚ ਤਬਦੀਲੀਆਂ, ਪਲੱਗਇਨ ਸਿਸਟਮ, ਅਤੇ ਗਤੀਸ਼ੀਲ ਇਵੈਂਟ ਹੈਂਡਲਿੰਗ ਵਿੱਚ ਲਾਭਦਾਇਕ ਹੈ. ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕੀਤੇ ਬਿਨਾਂ ਰੀਅਲ-ਟਾਈਮ ਸੋਧਾਂ ਲਈ ਇਜ਼ਾਜਤ ਦਿੰਦਾ ਹੈ. ਭਾਵੇਂ ਤੁਸੀਂ ਡਿਜੀਟਲ ਕਾਰਡ ਗੇਮ ਜਾਂ ਇੰਟਰਐਕਟਿਵ ਸਿਮੂਲੇਸ਼ਨ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰ ਰਹੇ ਹੋ, ਮਾਸਟਰਿੰਗ ਫੰਕਸ਼ਨ ਤਬਦੀਲੀ ਦੀਆਂ ਤਕਨੀਕਾਂ ਤੁਹਾਡੇ ਵਿਕਾਸ ਕਾਰਜਾਂ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਬਹੁਤ ਵਧਾ ਦਿੰਦੀਆਂ ਹਨ. 🚀

ਹੋਰ ਪੜ੍ਹਨ ਅਤੇ ਹਵਾਲੇ

ਉੱਤੇ ਵਿਸਤ੍ਰਿਤ ਵਿਆਖਿਆ std :: ਕਾਰਜ ਅਤੇ ਇਸ ਦੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਸੀ ++ ਵਿਚ: cppression.com
ਦੀ ਵਰਤੋਂ ਲਾਂਬਦਾ ਕਾਰਜ ਵਿਹਾਰ ਨੂੰ ਸੋਧਣ ਲਈ: ਸਿਖਲਾਈਕੱਪ.ਕਾੱਮ
ਫੰਕਸ਼ਨ ਪੁਆਇੰਟਸ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਵਿਕਲਪਾਂ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸ: ਆਈਐਸਓ ਸੀ ++ ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ
ਨੂੰ ਸਮਝਣਾ ਸਜਾਵਟ ਪੈਟਰਨ ਖੇਡ ਵਿਕਾਸ ਵਿਚ: ਗੇਮ ਪ੍ਰੋਗਰਾਮਿੰਗ ਪੈਟਰਨ

C ++ ਵਿਚ ਡਾਇਨਾਮਿਕ ਫੰਕਸ਼ਨ ਰਿਪਲੇਸਮੈਂਟ ਕਾਰਡ ਗੇਮ ਮਕੈਨਿਕਸ ਲਈ