दिलचस्प पोस्ट
IIS8 में IIS_IUSRS और IUSR अनुमतियाँ Div अंदर सूची की अनुमति है? चैनल पर सभी वीडियो लाने के लिए यूट्यूब एपीआई HTML5 वेब ऐप में OAuth2 का उपयोग करना मैं एक .so फ़ाइल में प्रतीकों की सूची कैसे करूं? सप्ताह की शुरुआत और समाप्ति की तिथि को एक वर्तमान तिथि और सप्ताह की शुरुआत के साथ प्राप्त करें IDisposable को लागू करने के लिए सामान्य नियम संपादन टेक्स्ट पर एंड्रॉइड में ईमेल एड्रेस वैधीकरण .NET के साथ CSV पार्सिंग विकल्प एक बाश खोल स्क्रिप्ट में सभी तर्कों का प्रचार करें बैच फ़ाइल – फ़ोल्डर में फ़ाइलों की संख्या की गिनती और एक चर में भंडारण PHP द्वारा वेबपेज के ओपन ग्राफ़ प्रोटोकॉल कैसे प्राप्त करें? लिनक टू एसक्यूएल "कैसे में (मानों की सूची)" कैसे करें संस्कृति की परवाह किए बिना दशमलव मूल्यों की संख्या का पता लगाएं बहुरूपता का वर्णन करने की कोशिश करें जितना आसान हो सकता है

एक ही नाम के साथ बहु-विरासत कार्य क्यों करते हैं लेकिन अलग-अलग हस्ताक्षर को अतिभारित कार्यों के रूप में नहीं माना जाता?

निम्नलिखित स्निपेट संकलन के दौरान एक "विवादास्पद कॉल फू" त्रुटि उत्पन्न करता है, और मुझे यह जानना चाहिए कि इस समस्या के चारों ओर कोई रास्ता नहीं है, तो फ़ू को कॉल पूरी तरह से क्वालिटी के बिना:

#include <iostream> struct Base1{ void foo(int){ } }; struct Base2{ void foo(float){ } }; struct Derived : public Base1, public Base2{ }; int main(){ Derived d; d.foo(5); std::cin.get(); return 0; } 

इसलिए, प्रश्न शीर्षक के रूप में कहते हैं। विचार? मेरा मतलब है, निम्नलिखित काम flawlessly:

 #include <iostream> struct Base{ void foo(int){ } }; struct Derived : public Base{ void foo(float){ } }; int main(){ Derived d; d.foo(5); std::cin.get(); return 0; } 

Solutions Collecting From Web of "एक ही नाम के साथ बहु-विरासत कार्य क्यों करते हैं लेकिन अलग-अलग हस्ताक्षर को अतिभारित कार्यों के रूप में नहीं माना जाता?"

सदस्य लुकअप नियम अनुभाग 10.2 / 2 में परिभाषित किए गए हैं

निम्नलिखित स्टेप्स क्लास स्कोप में नाम लुकअप के परिणाम को परिभाषित करता है, C सबसे पहले, वर्ग में नाम के लिए और इसके प्रत्येक बेस वर्ग के सब-ऑब्जेक्ट्स के लिए प्रत्येक घोषणापत्र माना जाता है। एक उप-ऑब्जेक्ट B एक सदस्य का नाम f उप-ऑब्जेक्ट में एक सदस्य का नाम छिपाता है A अगर A का एक बेस क्लास उप-ऑब्जेक्ट है। किसी भी घोषणाएं जो छिपी हैं वे विचार से समाप्त हो जाती हैं । इनमें से प्रत्येक घोषणापत्र जो उपयोग-घोषणा द्वारा प्रस्तुत किया गया था, C प्रत्येक उप-वस्तु से माना C है, जो उस प्रकार का होता है जिसमें उपयोग-घोषणा द्वारा निर्दिष्ट घोषणापत्र- यदि घोषणाओं का परिणामस्वरूप सेट सभी एक ही प्रकार के उप-वस्तुओं से नहीं होते हैं, या सेट में एक गैर-सदस्यीय सदस्य होता है और इसमें अलग-अलग उप-वस्तुओं के सदस्य शामिल होते हैं, तो एक अस्पष्टता है और कार्यक्रम का खराब स्वरूप है । अन्यथा यह सेट लुकअप का नतीजा है।

 class A { public: int f(int); }; class B { public: int f(); }; class C : public A, public B {}; int main() { C c; cf(); // ambiguous } 

तो आप उस अस्पष्टता को हल करने के लिए A::f घोषणा A::f और B::f using उपयोग कर सकते हैं

 class C : public A, public B { using A::f; using B::f; }; int main() { C c; cf(); // fine } 

द्वितीय कोड void foo(float) काम करता है क्योंकि void foo(float) सी के दायरे के अंदर है। वास्तव में d.foo(5); void foo(float) कॉल करें और int संस्करण नहीं।

क्या यह आपके लिए कारगर होगा।

 struct Derived : public Base1, public Base2{ using Base2::foo;} 

नाम लुकअप ओवरलोड संकल्प के लिए एक अलग चरण है।

नाम लुकअप पहले दिखता है यह तय करने की प्रक्रिया है कि नाम किस क्षेत्र पर लागू होता है। इस मामले में हमें यह तय करना होगा कि d.foo मतलब है d.B1::foo , या d.B2::foo , या d.B2::foo नाम लुकअप नियम फ़ंक्शन पैरामीटर या कुछ भी खाते में नहीं लेते हैं; यह विशुद्ध रूप से नाम और scopes के बारे में है।

केवल एक बार निर्णय लिया गया है, तो क्या हम उस कार्य के विभिन्न अधिभारों पर ओवरलोड रिज़ॉल्यूशन करते हैं, जहां उस क्षेत्र में नाम दिया गया था।

आपके उदाहरण में, d.foo() को कॉल करने पर D::foo() मिलेगा यदि ऐसा फ़ंक्शन होता है लेकिन कोई नहीं है इसलिए, scopes के पीछे पीछे काम करते हुए, यह आधार कक्षाओं की कोशिश करता है। अब foo B1::foo या B2::foo foo को समान रूप से देख सकता है, इसलिए यह अस्पष्ट है

इसी कारण से, आपको अयोग्य ठहराए गए foo(5); कॉल करने में अस्पष्टता मिलेगी foo(5); एक D सदस्य समारोह के अंदर


अनुशंसित समाधान का प्रभाव:

 struct Derived : public Base1, public Base2{ using Base1::foo; using Base2::foo; 

यह है कि यह नाम D::foo बनाता है, और इसे दो कार्यों की पहचान करता है नतीजा यह है कि d.foo dD::foo को हल करता है, और फिर इन दो कार्यों पर ओवरलोड संकल्प हो सकता है जो D::foo द्वारा पहचाने जाते हैं।

नोट: इस उदाहरण में D::foo(int) और Base1::foo(int) एक फ़ंक्शन के लिए दो पहचानकर्ता हैं; लेकिन सामान्य रूप से, नाम देखने और ओवरलोड संकल्प प्रक्रिया के लिए, यह कोई फर्क नहीं पड़ता कि क्या वे दो अलग फ़ंक्शंस हैं या नहीं।