variadic का उपयोग कर टेम्पलेट lambdas: जी के साथ त्रुटि ++ लेकिन बजना ++ के साथ चल रहा

Question

, variadic टेम्पलेट्स, कक्षाएं, कार्यों और lambdas के साथ खेलने के दौरान (from here) मैंने पाया कि निम्न कोड clang++ जबकि नहींg++ के साथ चल साथ चल रहा है:

#include <iostream> 
#include <string> 
using namespace std; 
template <class... F> 
struct overload_set : F... 
{ 
    overload_set(F... f) : F(f)... {} 
}; 
template <class... F> 
auto overload(F... f) 
{ 
    return overload_set<F...>(f...); 
} 
int main() 
{ 
    auto func = overload (
     [](int &val) { val *= 2; }, 
     [](string &arg) { arg += arg; }, 
     [](char &c) { c = 'x'; } 
     ); 
    int val = 10; 
    string str = "stackoverflow"; 
    char ch = 's'; 
    cout << val << " : " << str << " : " << ch << endl; 
    func(val); 
    func(str); 
    func(ch); 
    cout << val << " : " << str << " : " << ch << endl; 
    return 0; 
} 

clang लिए

: coliru

g++ के लिए: coliru

g++operator()func(val), func(str) और func(c) के लिए संदिग्ध operator() दे रहा है। मुझे लगता है कि operator() संदिग्ध नहीं होना चाहिए, क्योंकि प्रत्येक के पास अलग-अलग तर्क हैं।

g++ के साथ समस्या क्या है?

Answer 1

यह लैम्बडा, वैरैडिक टेम्पलेट्स, ऑपरेटरों या किसी भी उन्नत सी ++ 1 {xy} सामान के साथ बहुत कम नहीं है। के आसान बनाने में करते हैं:

struct foo 
{ 
    void func(int&){} 
}; 
struct bar 
{ 
    void func(char&){} 
}; 

struct test : foo, bar {}; 

int main() 
{ 
    test t; 
    int i = 1; 
    char c = 'a'; 
    t.func(i); 
    t.func(c); 
} 

यह या तो g++ या clang++ में संकलित करने के लिए विफल रहता है। जो भी अच्छी बात है, क्योंकि इस तरह भाषा को काम करने के लिए निर्दिष्ट किया गया है।

अगर हम बदलने funcoperator() को, g++ कार्यक्रम को अस्वीकार करने के लिए जारी है लेकिन clang++ या तो स्वीकार करता है या यह को खारिज कर दिया, कैसे ऑपरेटर कहा जाता है पर निर्भर करता है:

t.operator()(c); // rejected 
t(c);   // accepted 

जो मेरे लिए एक बजना बग की तरह दिखता है।

क्रम संकलन ऊपर कोड बनाने के लिए, एक बहुत छोटे से बदलाव की आवश्यकता है:

struct test : foo, bar { 
    using foo::func; 
    using bar::func; 
}; 

अब मैं पता नहीं निर्देशों का उपयोग में पैक विस्तार काम करने के लिए कैसे, या यह वास्तव में संभव है अगर की है।

template <class... F> struct overload_set; 

template <> struct overload_set<> {}; 

template <class F> struct overload_set<F> : F { 
    using F::operator(); 
    overload_set(F f) : F(f) {} 
}; 

template <class F, class... Fs> 
struct overload_set<F, Fs...> : F, overload_set<Fs...> 
{ 
    overload_set(F f, Fs... fs) : F(f), overload_set<Fs...>(fs...) {} 
    using F::operator(); 
    using overload_set<Fs...>::operator(); 
}; 

इस के साथ

बदलने अपने कोड g++ और clang++ दोनों के साथ संकलित: लेकिन वहाँ एक समाधान है।