दिलचस्प पोस्ट
इकाई फ़्रेमवर्क में ऑब्जेक्ट मौजूद है या नहीं, यह जांचने का सर्वोत्तम तरीका है? चयनित नोड, उसके लिंक, और उसके बच्चों को डी 3 बल निर्देशित ग्राफ़ में हाइलाइट करें क्यों उनके कंटेनर से बचने के फ्लोटिंग तत्वों को अतिप्रवाह छुपा दिया जाता है? एंड्रॉइड – फोन अनलॉक ईवेंट का पता लगाएं, स्क्रीन पर नहीं PHP में फैक्टरी डिजाइन पैटर्न क्या है? एंड्रॉइड में बिटमैप का आकार बदलने के लिए कैसे? कुछ परिस्थितियों में आवश्यक सत्यापन विशेषता अक्षम करें स्प्रिंग एक्सएमएल फाइल को @ कॉन्फ़िगरेशन क्लास में कनवर्ट करना क्रॉस कॉन्टेक्स्ट का अनुकरण – LINQ / C # क्या एल्िप्सस = "मार्की" हमेशा स्क्रॉल करने का कोई तरीका है? WebBrowser नियंत्रण में प्रदान की जाने वाली HTML (जावास्क्रिप्ट द्वारा संसाधित) कैसे प्राप्त करें? जावा 5 और जावा 6 के लिए-पर-उड़, इन-मेमोरी जावा कोड संकलन सी # नाम स्थान उपनाम – क्या बात है? TextView या WebView में टेक्स्ट हाइलाइट करें स्ट्रिंग :: c_str () अब सी + + 11 में समाप्त नहीं है?

वापसी के प्रकार से फ़ंक्शन ओवरलोडिंग?

अधिक मुख्यधारा के कारण स्टैटिकली टाइप की गई भाषाएं फ़ॉरवर्ड / फ़ॉरवर्ड टाइपिंग प्रकार से ओवरलोडिंग का समर्थन नहीं करती हैं? मैं किसी भी ऐसा नहीं सोच सकता यह पैरामीटर प्रकार के आधार पर ओवरलोड का समर्थन करने से कम उपयोगी या उचित नहीं लगता है। यह कितना कम लोकप्रिय है?

वेब के समाधान से एकत्रित समाधान "वापसी के प्रकार से फ़ंक्शन ओवरलोडिंग?"

दूसरे लोग क्या कह रहे हैं, इसके विपरीत, वापसी प्रकार से अतिभारित संभव है और कुछ आधुनिक भाषाओं द्वारा किया जाता है। सामान्य आपत्ति यह है कि कोड में जैसे

int func(); string func(); int main() { func(); } 

आप नहीं बता सकते हैं कि कौन सी func() कहा जा रहा है। इसे कुछ तरीकों से हल किया जा सकता है:

  1. ऐसी स्थिति में निर्धारित किया जा सकता है कि कौन-सी समारोह को कहा जाता है।
  2. जब भी ऐसी स्थिति होती है, यह एक संकलन-समय त्रुटि है हालांकि, एक वाक्यविन्यास है जो प्रोग्रामर को अलग करने की अनुमति देता है, जैसे कि int main() { (string)func(); } int main() { (string)func(); }
  3. साइड इफेक्ट्स न करें यदि आपके पास साइड इफेक्ट्स नहीं हैं और आप फ़ंक्शन के रिटर्न वैल्यू का उपयोग नहीं करते हैं, तो कंपाइलर फ़ंक्शन को पहले स्थान पर कॉल करने से बचा सकता है।

दो भाषाओं में मैं नियमित रूप से ( एबी ) अतिप्रवाह का उपयोग प्रकार के प्रकार: पर्ल और हास्केल । मुझे बताएं कि वे क्या करते हैं।

पर्ल में , स्केलर और सूची संदर्भ (और अन्य के बीच एक मूलभूत अंतर है, लेकिन हम दो का दिखावा करेंगे)। पर्ल में प्रत्येक निर्मित फ़ंक्शन, उस संदर्भ के आधार पर अलग-अलग कार्य कर सकता है जिसमें इसे कहा जाता है। उदाहरण के लिए, join ऑपरेटर बलों की सूची संदर्भ (वस्तु में शामिल होने पर) जबकि scalar ऑपरेटर बेशक स्केलर संदर्भ, तो तुलना करें:

 print join " ", localtime(); # printed "58 11 2 14 0 109 3 13 0" for me right now print scalar localtime(); # printed "Wed Jan 14 02:12:44 2009" for me right now. 

पर्ल में हर ऑपरेटर स्केलर संदर्भ में कुछ और सूची संदर्भ में कुछ करता है, और वे भिन्न हो सकते हैं, जैसा कि सचित्र है (यह सिर्फ localtime जैसे यादृच्छिक ऑपरेटर के लिए नहीं है। यदि आप सूची संदर्भ में @a उपयोग करते हैं, तो यह सरणी देता है, जबकि स्केलर संदर्भ में, यह तत्वों की संख्या देता है। उदाहरण के लिए print @a तत्वों को प्रिंट करता है , जबकि print 0+@a आकार प्रिंट करता है।) इसके अलावा, प्रत्येक ऑपरेटर संदर्भ को मजबूर कर सकते हैं, जैसे कि अतिरिक्त + स्केलर संदर्भ बल man perlfunc में हर प्रविष्टि दस्तावेजों यह। उदाहरण के लिए, यहां glob EXPR लिए प्रविष्टि का हिस्सा है:

सूची संदर्भ में, EXPR के मान पर फ़ाइल नाम विस्तारों की एक (संभवतः रिक्त) सूची EXPR जैसे मानक यूनिक्स शेल /bin/csh EXPR स्केलर के संदर्भ में, ग्लोब ऐसे फाइलनाम विस्तार के माध्यम से चलाता है, जब सूची समाप्त हो जाती है तो वह वापस नहीं लौटाता।

अब, सूची और स्केलर संदर्भ के बीच संबंध क्या है? खैर, man perlfunc कहते हैं

निम्न महत्वपूर्ण नियम को याद रखें: कोई नियम नहीं है जो कि सूची के संदर्भ में अभिव्यक्ति के व्यवहार को स्केलर संदर्भ में उसके व्यवहार के संदर्भ में, या इसके विपरीत से संबंधित है। यह दो पूरी तरह से अलग चीजें कर सकती है प्रत्येक ऑपरेटर और फ़ंक्शन यह निर्धारित करता है कि किस प्रकार के मूल्य को स्केलर संदर्भ में वापस करना सबसे उपयुक्त होगा। कुछ ऑपरेटर सूची की लंबाई लौटते हैं जो सूची के संदर्भ में वापस आ गए होंगे। कुछ ऑपरेटरों सूची में पहला मान वापस आते हैं। कुछ ऑपरेटर्स सूची में अंतिम मान वापस लौटते हैं। कुछ ऑपरेटर सफल संचालन की गिनती वापस करते हैं। सामान्यतया, वे जो आप चाहते हैं, जब तक आप निरंतरता नहीं चाहते हैं

इसलिए यह एक एकल कार्य करने का एक सरल मामला नहीं है, और फिर आप अंत में सरल रूपांतरण करते हैं। वास्तव में, मैंने इस कारण के लिए localtime उदाहरण चुना।

यह सिर्फ ऐसे बिल्ट-इन नहीं हैं जो इस व्यवहार के होते हैं। कोई भी उपयोगकर्ता इस तरह के फ़ंक्शन को wantarray का उपयोग करके परिभाषित कर wantarray , जिससे आप सूची, स्केलर और शून्य संदर्भ के बीच भेद कर सकते हैं। इसलिए, उदाहरण के लिए, आप कुछ भी नहीं करने का निर्णय ले सकते हैं यदि आपको शून्य संदर्भ में कहा जा रहा है

अब, आप शिकायत कर सकते हैं कि यह बदले मूल्य से अतिभारित नहीं है क्योंकि आपके पास केवल एक फ़ंक्शन है, जिसे उस संदर्भ में बताया गया है जिसे उसमें कहा जाता है और फिर उस जानकारी पर कार्य करता है हालांकि, यह स्पष्ट रूप से समतुल्य है (और यह कैसे समान है कि पर्ल सामान्य रूप से अधिभार को शाब्दिक रूप से अनुमति नहीं देता है, लेकिन एक फ़ंक्शन केवल अपने तर्कों की जांच कर सकता है)। इसके अलावा, यह अच्छी तरह से इस प्रतिक्रिया की शुरुआत में उल्लिखित अस्पष्ट स्थिति को हल करता है। पर्ल शिकायत नहीं करता है कि उसे पता नहीं है कि किस पद्धति को कॉल करना है; यह सिर्फ यह कहता है यह करने के लिए सभी को यह पता लगाना है कि समारोह को किस संदर्भ में बुलाया गया था, जो हमेशा संभव होता है:

 sub func { if( not defined wantarray ) { print "void\n"; } elsif( wantarray ) { print "list\n"; } else { print "scalar\n"; } } func(); # prints "void" () = func(); # prints "list" 0+func(); # prints "scalar" 

(ध्यान दें: मैं कभी-कभी फ़र्ज़ल ऑपरेटर कह सकता हूँ जब यह फ़ंक्शन होता है। यह इस चर्चा के लिए महत्वपूर्ण नहीं है।)

हास्केल अन्य दृष्टिकोण लेता है, अर्थात् साइड इफेक्ट नहीं होने के लिए। इसमें एक मजबूत प्रकार प्रणाली भी है, और इसलिए आप निम्न तरह से कोड लिख सकते हैं:

 main = do n <- readLn print (sqrt n) -- note that this is aligned below the n, if you care to run this 

यह कोड मानक इनपुट से एक अस्थायी बिंदु संख्या पढ़ता है, और इसके वर्गमूल को प्रिंट करता है। लेकिन इसके बारे में आश्चर्य की बात क्या है? खैर, readLn का प्रकार readLn :: Read a => IO a । इसका मतलब यह है कि किसी भी प्रकार के लिए Read जा सकता है (औपचारिक रूप से, प्रत्येक प्रकार जो Read प्रकार वर्ग का एक उदाहरण है), readLn इसे पढ़ सकता है हास्केल को कैसे पता था कि मैं एक अस्थायी बिंदु संख्या पढ़ना चाहता था? खैर, sqrt का प्रकार sqrt :: Floating a => a -> a , जिसका अनिवार्य रूप से अर्थ है कि sqrt केवल इनपुट बिंदुओं के रूप में फ़्लोटिंग बिंदु संख्या स्वीकार कर सकता है, और इसलिए हास्केल ने मुझे जो चाहते थे अनुमान लगाया।

क्या होता है जब हास्केल मुझे जो चाहते हैं इसका अनुमान नहीं लगा सकता है? ठीक है, वहाँ कुछ संभावनाएं हैं अगर मैं वापसी मूल्य का बिल्कुल उपयोग नहीं करता हूं, तो हास्केल केवल फ़ंक्शन को पहले स्थान पर नहीं बुलाएगा। हालांकि, अगर मैं वापसी मूल्य का उपयोग करता हूं, तो हास्केल शिकायत करेगा कि वह इस प्रकार का अनुमान नहीं लगा सकता है:

 main = do n <- readLn print n -- this program results in a compile-time error "Unresolved top-level overloading" 

मैं इच्छित प्रकार को निर्दिष्ट करके अस्पष्टता को हल कर सकता हूं:

 main = do n <- readLn print (n::Int) -- this compiles (and does what I want) 

वैसे भी, इस पूरी चर्चा का मतलब यह है कि रिटर्न वैल्यू से अधिक बोझ करना संभव है और किया जाता है, जो आपके प्रश्न का उत्तर देता है।

आपके प्रश्न का दूसरा भाग यही है कि अधिक भाषाओं ऐसा क्यों नहीं करते हैं। मैं दूसरों को इसका जवाब दूँगा हालांकि, कुछ टिप्पणियां: सिद्धांत कारण संभवतः तर्क है कि भ्रम का मौका वास्तव में तर्क प्रकार से अधिक भार से अधिक है। आप व्यक्तिगत भाषा से तर्कसंगत भी देख सकते हैं:

एडीए : "ऐसा लगता है कि सरलीकृत अधिभार संकल्प नियम सभी का उपयोग करना है – जितना संभव हो उतना विस्तृत संदर्भ से सभी जानकारी – अतिभारित संदर्भ को हल करने के लिए। यह नियम सरल हो सकता है, लेकिन यह उपयोगी नहीं है। इसके लिए मानव पाठक मनमाने ढंग से पाठ के बड़े टुकड़े को स्कैन करने के लिए, और मनमाने ढंग से जटिल उदाहरणों (जैसे ऊपर (जी) के रूप में)। हम मानते हैं कि एक बेहतर नियम एक है जो एक मानवीय पाठक या संकलक को काम करना चाहिए, और वह यह काम करता है संभव के रूप में मानव पाठक के लिए प्राकृतिक। "

सी ++ (बर्जने स्ट्रास्ट्रस के "सी ++ प्रोग्रामिंग भाषा" के उप-भाग 7.4.1): "लौटाने वाले प्रकारों को अधिभार संकल्प में नहीं माना जाता है। कारण एक स्वतंत्र ऑपरेटर या फ़ंक्शन कॉल संदर्भ-स्वतंत्र के लिए संकल्प रखना है। विचार करें:

 float sqrt(float); double sqrt(double); void f(double da, float fla) { float fl = sqrt(da); // call sqrt(double) double d = sqrt(da); // call sqrt(double) fl = sqrt(fla); // call sqrt(float) d = sqrt(fla); // call sqrt(float) } 

यदि वापसी प्रकार को ध्यान में रखा गया था, तो यह अलगाव में sqrt() कॉल को देखने के लिए संभव नहीं होगा और यह निर्धारित करेगा कि किस फ़ंक्शन को बुलाया गया था। "(नोट, तुलना के लिए, हस्केले में कोई निहित रूपांतरण नहीं है।)

जावा ( जावा भाषा विशिष्टता 9.4.1 ): "इनहेरिट की गई विधियों में से एक को किसी अन्य विरासत में मिली पद्धति के लिए प्रतिफल योग्य प्रकार होना चाहिए; अन्यथा, एक संकलन-समय त्रुटि उत्पन्न होती है।" (हां, मुझे पता है कि यह कोई तर्क नहीं देता है। मुझे यकीन है कि गोस्लिंग द्वारा "जावा प्रोग्रामिंग भाषा" में तर्क दिया जाता है। शायद किसी के पास एक प्रति है? मुझे यकीन है कि यह सार में "कम से कम आश्चर्य का सिद्धांत" है। ) हालांकि, जावा के बारे में मजेदार तथ्य: जेवीएम वापसी मूल्य द्वारा ओवरलोडिंग की अनुमति देता है ! उदाहरण के लिए, स्काला में इसका प्रयोग किया जाता है, और आंतरिक के साथ खेलने के साथ ही सीधे जावा के माध्यम से पहुंचा जा सकता है

पुनश्च। एक अंतिम नोट के रूप में, वास्तव में संभव है कि चाल के साथ C ++ में रिटर्न वैल्यू द्वारा ओवरलोड हो। गवाह:

 struct func { operator string() { return "1";} operator int() { return 2; } }; int main( ) { int x = func(); // calls int version string y = func(); // calls string version double d = func(); // calls int version cout << func() << endl; // calls int version func(); // calls neither } 

यदि फ़ंक्शंस रिटर्न प्रकार से अतिभारित होते हैं और आपके पास ये दो अधिभार होते हैं

 int func(); string func(); 

ऐसा कोई तरीका नहीं है कि कंपाइलर इस तरह से एक कॉल को देखने के लिए कॉल करने के लिए उन दोनों फ़ंक्शंस का पता लगा सकता है

 void main() { func(); } 

इस कारण से, भाषा डिजाइनर अक्सर बदले-मूल्य ओवरलोडिंग की अनुमति नहीं देते हैं।

कुछ भाषाएं (जैसे कि एमएसआईएल), हालांकि, वापसी प्रकार द्वारा ओवरलोडिंग की अनुमति नहीं देते हैं। वे भी पाठ्यक्रम की उपरोक्त कठिनाई का सामना करते हैं, लेकिन उनके पास काम करने के उपाय हैं, जिसके लिए आपको अपने दस्तावेज़ों से परामर्श करना होगा।

ऐसी भाषा में, आप निम्न को कैसे हल करेंगे:

 f(g(x)) 

यदि f में void f(int) अधिक भार void f(int) और void f(string) और g को अधिभार g था int g(int) और string g(int) ? आपको कुछ प्रकार की असंबद्धकर्ता की आवश्यकता होगी।

मुझे लगता है कि परिस्थितियों के लिए जहां आपको इसकी आवश्यकता हो सकती है, फ़ंक्शन के लिए एक नया नाम चुनकर बेहतर सेवा प्रदान की जाएगी।

किसी अन्य बहुत ही समान प्रश्न (धोखे) से एक सी ++ विशिष्ट उत्तर चुराने के लिए:


फ़ंक्शन रिटर्न प्रकार ओवरलोड संकल्प में नाटक में नहीं आते हैं, क्योंकि स्ट्राउटस्ट्रुप (मैं अन्य सी ++ आर्किटेक्ट्स से इनपुट के साथ ग्रहण करता हूं) अधिभार संकल्प 'संदर्भ स्वतंत्र' होने के लिए चाहता था 7.4.1 देखें – "सी ++ प्रोग्रामिंग भाषा, तीसरा संस्करण" से "ओवरलोडिंग और वापसी प्रकार"।

इसका कारण एक व्यक्ति ऑपरेटर या फ़ंक्शन कॉल संदर्भ-स्वतंत्र के लिए संकल्प रखना है

वे चाहते थे कि यह केवल अधिभार के नाम पर कैसे लागू किया गया – न कि परिणाम का उपयोग कैसे किया जाता है (यदि इसका उपयोग सभी में किया गया था)। दरअसल, कई कार्यों को नतीजे के बिना बुलाया जाता है या नतीजा एक बड़ा अभिव्यक्ति के भाग के रूप में इस्तेमाल किया जाएगा एक पहलू जो मुझे यकीन है कि जब यह निर्णय लिया गया था कि वह खेल में आया तो यह था कि यदि रिटर्न का प्रकार संकल्प का हिस्सा था, तो अतिभारित कार्यों के लिए कई कॉल होंगे जिन्हें जटिल नियमों के साथ हल करने की आवश्यकता होगी या कम्पाइलर फेंक करना होगा एक त्रुटि है कि कॉल अस्पष्ट था

और, भगवान जानता है, सी + + अधिभार संकल्प काफी जटिल है क्योंकि यह खड़ा है …

हैकेल में यह संभव है भले ही इसके पास ओवरलोडिंग फ़ंक्शन न हो। हास्केल टाइप क्लासेस का उपयोग करता है। एक प्रोग्राम में आप देख सकते हैं:

 class Example a where example :: Integer -> a instance Example Integer where -- example is now implemented for Integer example :: Integer -> Integer example i = i * 10 

फ़ंक्शन अपने आप को अतिभारित करना इतना लोकप्रिय नहीं है अधिकतर भाषाओं में मैंने इसके साथ देखा है सी ++, शायद जावा और / या सी # सभी गतिशील भाषाओं में इसके लिए एक लघुकथा है:

 define example:i ↑i type route: Integer = [↑i & 0xff] String = [↑i upper] def example(i): if isinstance(i, int): return i & 0xff elif isinstance(i, str): return i.upper() 

इसलिए इसमें कोई ज्यादा बात नहीं है। अधिकांश लोगों को इस बात से कोई दिलचस्पी नहीं है कि भाषा आप जहां तक ​​कभी भी इसका उपयोग करते हैं, प्रति एक पंक्ति ड्रॉप करने में आपकी सहायता कर सकती है।

पैटर्न मेलिंग फ़ंक्शन ओवरलोडिंग के समान है, और मुझे लगता है कि कभी-कभी समान रूप से काम करते हैं। यह सामान्य नहीं है क्योंकि यह केवल कुछ कार्यक्रमों के लिए उपयोगी है और अधिकांश भाषाओं पर लागू करने के लिए मुश्किल है

आप देखते हैं कि भाषा में कार्यान्वित करने के लिए असीम रूप से कई अन्य बेहतर आसान सुविधाएं हैं, जिनमें शामिल हैं:

  • डायनामिक टाइपिंग
  • सूचियों, शब्दकोशों और यूनिकोड तारों के लिए आंतरिक समर्थन
  • अनुकूलन (जेआईटी, टाइप इनफ्रेंसिंग, कंपाइलिंग)
  • एकीकृत तैनाती उपकरण
  • पुस्तकालय समर्थन
  • सामुदायिक सहायता और सभा स्थल
  • रिच मानक पुस्तकालय
  • अच्छा वाक्यविन्यास
  • Eval प्रिंट लूप पढ़ें
  • चिंतनशील प्रोग्रामिंग के लिए सहायता

अच्छा जवाब! विशेष रूप से A.Rex का उत्तर बहुत विस्तृत और शिक्षाप्रद है। जैसा कि वह बताता है, जब lhs = func(); संकलित करते हैं तो सी ++ उपयोगकर्ता द्वारा प्रदान किए गए टाइप-कनवर्ज़न ऑपरेटरों पर विचार करता है lhs = func(); (जहां फ़्ंंक वास्तव में एक स्ट्रेट का नाम है) मेरा कामकाज थोड़ा अलग है – बेहतर नहीं, सिर्फ अलग (हालांकि यह एक ही मूल विचार पर आधारित है)।

जबकि मैं लिखना चाहता था …

 template <typename T> inline T func() { abort(); return T(); } template <> inline int func() { <<special code for int>> } template <> inline double func() { <<special code for double>> } .. etc, then .. int x = func(); // ambiguous! int x = func<int>(); // *also* ambiguous!? you're just being difficult, g++! 

मुझे एक ऐसे समाधान के साथ समाप्त हुआ जो एक पैरामीटर वाला स्ट्रेट (टी = वापसी प्रकार के साथ) का उपयोग करता है:

 template <typename T> struct func { operator T() { abort(); return T(); } }; // explicit specializations for supported types // (any code that includes this header can add more!) template <> inline func<int>::operator int() { <<special code for int>> } template <> inline func<double>::operator double() { <<special code for double>> } .. etc, then .. int x = func<int>(); // this is OK! double d = func<double>(); // also OK :) 

इस समाधान का एक लाभ यह है कि किसी भी कोड में ये टेम्प्लेट परिभाषाएं शामिल हैं और अधिक प्रकार के लिए अधिक विशेषज्ञताएं जोड़ सकते हैं। इसके अलावा आप आवश्यक रूप से संरचना के आंशिक विशेषज्ञता प्राप्त कर सकते हैं। उदाहरण के लिए, यदि आप सूचक प्रकार के लिए विशेष हैंडलिंग चाहते हैं:

 template <typename T> struct func<T*> { operator T*() { <<special handling for T*>> } }; 

एक नकारात्मक के रूप में, आप int x = func(); लिख नहीं सकते int x = func(); मेरे समाधान के साथ आपको int x = func<int>(); लिखना है int x = func<int>(); । आपको स्पष्ट रूप से यह कहना होगा कि टाइप कनवर्ज़न ऑपरेटर को देखकर संकलक को इसे बाहर करने के लिए कहने के बजाय वापसी का प्रकार क्या है। मैं कहूंगा कि "मेरे" समाधान और ए। रीक्स दोनों इस सी ++ दुविधा से निपटने के तरीके के एक पारे-इष्टतम मोर्चे में हैं 🙂

जैसा कि पहले से ही दिखाया गया है – किसी फ़ंक्शन की अस्पष्ट कॉल केवल वापसी प्रकार से भिन्न है, अस्पष्टता का परिचय देता है अस्पष्टता दोषपूर्ण कोड लाती है दोषपूर्ण कोड से बचा जाना चाहिए।

अस्पष्टता के प्रयास से प्रेरित जटिलता से पता चलता है कि यह एक अच्छा हैक नहीं है एक बौद्धिक अभ्यास के अलावा- क्यों संदर्भ पैरामीटर के साथ प्रक्रियाओं का उपयोग नहीं करें

 procedure(reference string){}; procedure(reference int){}; string blah; procedure(blah) 

यह ओवरलोडिंग सुविधा प्रबंधित करना कठिन नहीं है, अगर आप इसे थोड़ा अलग तरीके से देखते हैं निम्नलिखित को धयान मे रखते हुए,

 public Integer | String f(int choice){ if(choice==1){ return new string(); }else{ return new Integer(); }} 

यदि कोई भाषा ओवरलोडिंग लौटा देती है तो यह पैरामीटर अतिभारित करने की अनुमति देगा, लेकिन दोहराव नहीं। यह निम्न की समस्या का समाधान करेगा:

 main (){ f(x) } 

क्योंकि इसमें से चुनने के लिए केवल एक च (इंट पसंद) है

.NET में, कभी-कभी हम एक पैरामीटर का उपयोग सामान्य परिणाम से वांछित आउटपुट को इंगित करने के लिए करते हैं, और फिर हम जो उम्मीद करते हैं वह प्राप्त करने के लिए रूपांतरण बनाते हैं।

सी#

 public enum FooReturnType{ IntType, StringType, WeaType } class Wea { public override string ToString() { return "Wea class"; } } public static object Foo(FooReturnType type){ object result = null; if (type == FooReturnType.IntType) { /*Int related actions*/ result = 1; } else if (type == FooReturnType.StringType) { /*String related actions*/ result = "Some important text"; } else if (type == FooReturnType.WeaType) { /*Wea related actions*/ result = new Wea(); } return result; } static void Main(string[] args) { Console.WriteLine("Expecting Int from Foo: " + Foo(FooReturnType.IntType)); Console.WriteLine("Expecting String from Foo: " + Foo(FooReturnType.StringType)); Console.WriteLine("Expecting Wea from Foo: " + Foo(FooReturnType.WeaType)); Console.Read(); } 

शायद यह उदाहरण भी मदद कर सकता है:

सी ++

  #include <iostream> enum class FooReturnType{ //Only C++11 IntType, StringType, WeaType }_FooReturnType; class Wea{ public: const char* ToString(){ return "Wea class"; } }; void* Foo(FooReturnType type){ void* result = 0; if (type == FooReturnType::IntType) //Only C++11 { /*Int related actions*/ result = (void*)1; } else if (type == FooReturnType::StringType) //Only C++11 { /*String related actions*/ result = (void*)"Some important text"; } else if (type == FooReturnType::WeaType) //Only C++11 { /*Wea related actions*/ result = (void*)new Wea(); } return result; } int main(int argc, char* argv[]) { int intReturn = (int)Foo(FooReturnType::IntType); const char* stringReturn = (const char*)Foo(FooReturnType::StringType); Wea *someWea = static_cast<Wea*>(Foo(FooReturnType::WeaType)); std::cout << "Expecting Int from Foo: " << intReturn << std::endl; std::cout << "Expecting String from Foo: " << stringReturn << std::endl; std::cout << "Expecting Wea from Foo: " << someWea->ToString() << std::endl; delete someWea; // Don't leak oil! return 0; } 

अभिलेख के लिए, आक्टेव रिटर्न तत्व के अनुसार भिन्न परिणाम स्केलर बनाम अरैम की अनुमति देता है।

 x = min ([1, 3, 0, 2, 0]) ⇒ x = 0 [x, ix] = min ([1, 3, 0, 2, 0]) ⇒ x = 0 ix = 3 (item index) 

सीएफ भी एकवचन मूल्य में अपघटन

अधिकांश स्थैतिक भाषाएं भी जेनेरिकों का समर्थन करती हैं, जो आपकी समस्या को हल करेंगे। जैसा कि पहले कहा गया है, बिना पैरामीटर diffs के, कोई भी पता नहीं है कि किसको कॉल करना है। इसलिए यदि आप ऐसा करना चाहते हैं, तो सिर्फ जेनेरिक का उपयोग करें और इसे एक दिन कहते हैं।