यह इस बात पर निर्भर करता है कि आप विकास चक्र में कहां खड़े हैं, लेकिन कभी-कभी एक एल्गोरिथ्म से बाहर निकलने के दौरान, आप तुरंत उन्हें लागू किए बिना जटिल ब्लॉकों के बारे में अमूर्त बनाना चाहते हैं।
def full_algo():
init_stuff()
process_stuff()
...
आप जानते हैं कि यह कैसे init_stuff
काम करेगा, यह आपके सिर में सरल है, लेकिन आपको वास्तव में तुरंत इसकी आवश्यकता नहीं है, इसलिए आप इसे एक खाली फ़ंक्शन के रूप में घोषित करते हैं। यह आपके कोड को संकलित करने और चलाने के लिए अनुमति देगा बिना गोर विवरण के बारे में परेशान किए बिना।
जारी किए गए अनुप्रयोगों का एक अन्य उपयोग वंशानुक्रम का उपयोग करते समय होता है। मान लीजिए कि आपके पास एक बड़ा वर्ग है जो प्लेटफ़ॉर्म विशिष्ट कोड के व्यवहार को परिभाषित करता है। आप इसके समान एक तर्क के साथ समाप्त हो सकते हैं:
init_filesystem();
access_files();
release_filesystem();
यह कोड कई प्लेटफार्मों पर काम करेगा, लेकिन कुछ प्लेटफार्मों को फाइलसिस्टम आरंभीकरण की आवश्यकता नहीं हो सकती है। तब आपकी विरासत इस तरह दिखेगी (C ++ में वर्चुअल = 0 के साथ इसका मतलब है कि व्युत्पन्न वर्ग उन तरीकों को लागू करना होगा):
class FileSystem{
virtual void init_filesystem() = 0;
virtual void access_files() = 0;
virtual void release_filesystem() = 0;
};
फिर इस वर्ग (इंटरफ़ेस) का एक विशेष कार्यान्वयन उन तरीकों में से कुछ के लिए कुछ नहीं कर सकता है। वैकल्पिक रूप से, आधार वर्ग उन्हें आभासी घोषित करने के बजाय init / रिलीज़ के लिए खाली तरीकों की घोषणा कर सकता है।
अंत में और शर्मनाक तरीके से), कभी-कभी आप एक बहुत पुरानी एप्लिकेशन को बनाए रखते हैं। आपको डर है कि तरीकों को हटाने से चीजें टूट जाएंगी। यह तब होता है जब आपके पास जटिल विरासत होती है जिसे ठीक से समझा नहीं जाता है या जब आपके पास बहुत सारे फ़ंक्शन पॉइंटर्स (कॉलबैक) होते हैं। आप बस उनके अंदर कोड को हटा देते हैं ताकि वे बिना किसी को कुछ भी कहे कॉल कर सकें।