दिलचस्प पोस्ट
एजेएक्स संचालित साइट पर सही नियंत्रण को चुनना और सक्रिय करना सी # में चर गुंजाइश IE9 समर्थन console.log करता है, और क्या यह एक वास्तविक कार्य है? ऑफ़लाइन उपयोग के लिए Google मानचित्र टाइल कैश कैसे करें? java.sql.SQLException पैरामीटर इंडेक्स श्रेणी से बाहर (1> पैरामीटर की संख्या, जो 0 है) क्रोम के अंतर्गत संसाधन लोड करने में विफल बेस 64 एन्कोडिंग क्या इस्तेमाल किया जाता है? टिल्ड को फंक्शन नाम से पहले सी # में क्या होता है? कैसे सी # में एक पूर्णांक में एक IPv4 पता बदलने के लिए? सी में "स्थिर" क्या होता है? विंडोज फॉर्म में किसी अन्य फॉर्म पर नियंत्रण का उपयोग करने का सर्वोत्तम तरीका है? जावा में मार्कर इंटरफेस का क्या उपयोग है? पेस्ट इनपुट पकड़ो आईओएस दुर्घटना लॉग कैश, डीबग जानकारी .. पकड़ो और देव टीम को ईमेल के माध्यम से भेजें JSON युक्ति – कुंजी को उद्धरण चिह्नों से घिरा होना चाहिए?

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

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

#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; } 

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

सदस्य लुकअप नियम अनुभाग 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) एक फ़ंक्शन के लिए दो पहचानकर्ता हैं; लेकिन सामान्य रूप से, नाम देखने और ओवरलोड संकल्प प्रक्रिया के लिए, यह कोई फर्क नहीं पड़ता कि क्या वे दो अलग फ़ंक्शंस हैं या नहीं।