सी ++ ओवरलैडिंग तर्कों के लिए ओवरलोडिंग ऑपरेटर कॉमा

Question

क्या तर्क के ऑपरेटर कॉमा ओवरलोडिंग द्वारा फ़ंक्शन के लिए विविध तर्क बनाना संभव है? मैं एक उदाहरण देखना चाहता हूं कि ऐसा कैसे करें .. शायद कुछ ऐसा हो सकता है:

template <typename T> class ArgList { 
public: 
    ArgList(const T& a); 
    ArgList<T>& operator,(const T& a,const T& b); 
} 
//declaration 
void myFunction(ArgList<int> list); 

//in use: 
myFunction(1,2,3,4); 

//or maybe: 
myFunction(ArgList<int>(1),2,3,4); 

Answer 1

यह sort- है संभव है, लेकिन उपयोग बहुत अच्छा नहीं लगेगा। exxample के लिए:

#include <vector> 
#include <iostream> 
#include <algorithm> 
#include <iterator> 

template <class T> 
class list_of 
{ 
    std::vector<T> data; 
public: 
    typedef typename std::vector<T>::const_iterator const_iterator; 
    const_iterator begin() const { return data.begin(); } 
    const_iterator end() const { return data.end(); } 

    list_of& operator, (const T& t) { 
     data.push_back(t); 
     return *this; 
    } 
}; 

void print(const list_of<int>& args) 
{ 
    std::copy(args.begin(), args.end(), std::ostream_iterator<int>(std::cout, " ")); 
} 

int main() 
{ 
    print((list_of<int>(), 1, 2, 3, 4, 5)); 
} 

यह कमी C++ 0x में तय हो जाएगा कि आप कहां कर सकते हैं:

void print(const std::initializer_list<int>& args) 
{ 
    std::copy(args.begin(), args.end(), std::ostream_iterator<int>(std::cout, " ")); 
} 

int main() 
{ 
    print({1, 2, 3, 4, 5}); 
} 

या यहाँ तक कि मिश्रित प्रकार के साथ:

template <class T> 
void print(const T& t) 
{ 
    std::cout << t; 
} 

template <class Arg1, class ...ArgN> 
void print(const Arg1& a1, const ArgN& ...an) 
{ 
    std::cout << a1 << ' '; 
    print(an...); 
} 


int main() 
{ 
    print(1, 2.4, 'u', "hello world"); 
} 

Answer 2

ऑपरेटरों के पास निश्चित संख्या में पैरामीटर हैं। आप इसे बदल नहीं सकते। अल्पविराम ऑपरेटर दो तर्क लेता है। तो नहीं। हालांकि, कुछ प्रयासों के साथ आप एक कस्टम, कैस्केडिंग संस्करण रोल कर सकते हैं।

Answer 3

नहीं, ऐसा नहीं है। अल्पविराम ऑपरेटर द्वारा अलग मूल्यों की सूची का मूल्यांकन एक मूल्य के रूप में किया जाएगा। उदाहरण के लिए:

1,2,3 

एकल मान में परिणाम होगा, 3.

Answer 4

हो सकता है कि कुछ इस तरह:

class MyArgList { 
public: 
    typedef std::list<boost::any> ManyList; 

    template <typename T> 
    MyArgList& operator, (const T& val) { 
     elems.push_back(val); 
     return *this; 
    } 

    ManyList::iterator begin() {return elems.begin();} 
     ... 

private: 
    ManyList elems; 
}; 

प्रयोग होगा:

void foo(MyArgList& list); 
foo((myArgList(),1,2,3,4,5));