ADL फ़ंक्शन टेम्प्लेट क्यों नहीं खोजता है?

Question 1

C ++ विनिर्देशन का कौन-सा भाग संबद्ध नामस्थानों के सेट में फ़ंक्शन टेम्प्लेट खोजने से तर्क निर्भर देखने को प्रतिबंधित करता है? दूसरे शब्दों में, mainनीचे दिया गया अंतिम कॉल संकलन में विफल क्यों होता है ?

namespace ns {
    struct foo {};
    template<int i> void frob(foo const&) {}
    void non_template(foo const&) {}
}

int main() {
    ns::foo f;
    non_template(f); // This is fine.
    frob<0>(f); // This is not.
}

Question 2

यह हिस्सा इसे समझाता है:

सी ++ मानक 03 14.8.1.6 :

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

namespace A {
  struct B { };
  template<int X> void f(B);
}
namespace C {
  template<class T> void f(T t);
}
void g(A::B b) {
  f<3>(b);    //ill-formed: not a function call
  A::f<3>(b); //well-formed
  C::f<3>(b); //ill-formed; argument dependent lookup
              // applies only to unqualified names
  using C::f;
  f<3>(b);    //well-formed because C::f is visible; then
              // A::f is found by argument dependent lookup
}

Question 3

C ++ 20 के बाद से, adl भी स्पष्ट फ़ंक्शन टेम्पलेट के साथ ठीक काम करता है। यहाँ प्रस्ताव है: P0846R0: ADL और फ़ंक्शन टेम्प्लेट जो दृश्यमान नहीं हैं :

उपयोगकर्ता को टेम्प्लेट कीवर्ड का उपयोग करने की आवश्यकता के बजाय, लुकअप नियमों का एक संशोधन प्रस्तावित किया गया था, ताकि एक ऐसा नाम जिसके लिए एक सामान्य लुकअप या तो कोई परिणाम नहीं देता है या एक या एक से अधिक फ़ंक्शन पाता है और उसके बाद आ "<" के रूप में माना जाएगा। यदि कोई फ़ंक्शन टेम्प्लेट नाम पाया गया था और ADL का प्रदर्शन किया जाएगा।

वर्तमान में, केवल जीसीसी 9 ने इस सुविधा को लागू किया है, इसलिए आपका उदाहरण संकलन कर सकता है।

live demo।

Question 4

मैं थोड़ा स्वीकार किए गए उत्तर को परिष्कृत करना चाहूंगा। ओपी प्रश्न में यह स्पष्ट नहीं है, लेकिन मानक (कोर्नेल द्वारा उद्धृत) से महत्वपूर्ण हिस्सा यह है (जोर मेरा):

लेकिन जब स्पष्ट टेम्प्लेट तर्कों के साथ फ़ंक्शन टेम्पलेट का उपयोग किया जाता है, तो कॉल में सही वाक्यविन्यास फ़ॉर्म नहीं होता है

इसलिए जो निषिद्ध है वह ADL पर निर्भर है और स्पष्ट टेम्पलेट तर्क का उपयोग कर रहा है। दुर्भाग्य से गैर-प्रकार के टेम्पलेट तर्कों का उपयोग करने के लिए स्पष्ट तर्कों का उपयोग करने की आवश्यकता होती है (जब तक कि उनके पास डिफ़ॉल्ट मान न हों)।

नीचे नमूना कोड दिखाया गया है।

[लाइव]

#include <string>
#include <utility>

namespace C {
  struct B { };
  template<class T> void f(T t){}
}

void g(C::B b) {
  f(b);           // OK
  //f<C::B>(b);   // ill-formed: not a function call, but only 
                  //  because explicit template argument were used

  std::string s;
  move(s);                      // OK
  //move<std::string&>(s);      // Error, again because 
                                //  explicit template argument were used
  std::move<std::string&>(s);   // Ok
}

int main()
{
 C::B b;
 g(b);
}

Question 5

संपादित करें: नहीं, यह सही नहीं है। देखें @ कोर्नेल के जवाब ।

मुझे पूरी तरह यकीन नहीं है लेकिन स्ट्रॉस्ट्रुप की "द सी ++ प्रोग्रामिंग लैंग्वेज" से परामर्श करने के बाद मुझे लगता है कि अपेंडिक्स सी सेक्शन 13.8.4 का कारण हो सकता है।

चूँकि frobएक टेम्प्लेट है जिसे i=0आप इसे कॉल करने के बाद एक बिंदु पर विशेष रूप से उपयोग कर सकते हैं । इसका मतलब यह है कि कार्यान्वयन को चुनने के दो संभावित तरीकों के साथ छोड़ दिया जाएगा, frobजैसा कि यह प्रतीत होता है कि यह इसे तात्कालिकता के बिंदु पर या अनुवाद इकाई के प्रसंस्करण के अंत में चुन सकता है ।

इसलिए, मुझे लगता है कि समस्या यह है कि आप क्या कर सकते हैं

namespace ns {
    struct foo {};
    template<int i> void frob(foo const&) {}
}

int main() {
    ns::foo f;
    frob<0>(f);
    return 0;
}

namespace ns {
    template<> void frob< 0 >(foo const&) { /* Do something different*/ }
}