खोज…


टिप्पणियों

फोल्ड एक्सप्रेशन निम्नलिखित ऑपरेटरों के लिए समर्थित हैं

+ - * / % \ और | << >>
+ = - = * = / = % = \ = और = | = << = >> = =
== ! = < > <= > = && || , । * -> *

जब एक खाली अनुक्रम को मोड़ते हैं, तो निम्न तीन ऑपरेटरों को छोड़कर, एक गुना अभिव्यक्ति बीमार होती है:

ऑपरेटर पैरामीटर पैक खाली होने पर मान
&& सच
|| असत्य
, शून्य ()

एकतरफा मोहरें

एक विशिष्ट ऑपरेटर के पैरामीटर पैकों को मोड़ने के लिए अनकही सिलवटों का उपयोग किया जाता है। 2 प्रकार के एकात्मक तह हैं:

  • Unary Left Fold (... op pack) जो इस प्रकार है:

    ((Pack1 op Pack2) op ...) op PackN
    
  • यूनिरी राइट फोल्ड (pack op ...) जो इस प्रकार है:

    Pack1 op (... (Pack(N-1) op PackN)) 
    

यहाँ एक उदाहरण है

template<typename... Ts>
int sum(Ts... args)
{
    return (... + args); //Unary left fold
    //return (args + ...); //Unary right fold

    // The two are equivalent if the operator is associative.
    // For +, ((1+2)+3) (left fold) == (1+(2+3)) (right fold)
    // For -, ((1-2)-3) (left fold) != (1-(2-3)) (right fold)
}

int result = sum(1, 2, 3); //  6

बाइनरी फोल्ड्स

अतिरिक्त तर्क के साथ बाइनरी फोल्ड्स मूल रूप से एकांतरिक सिलवट हैं।

बाइनरी फोल्ड के 2 प्रकार हैं:

  • बाइनरी लेफ्ट फोल्ड - (value op ... op pack) - इस प्रकार है:

    (((Value op Pack1) op Pack2) op ...) op PackN
    
  • बाइनरी राइट फोल्ड (pack op ... op value) - विस्तार इस प्रकार है:

    Pack1 op (... op (Pack(N-1) op (PackN op Value)))
    

यहाँ एक उदाहरण है:

template<typename... Ts>
int removeFrom(int num, Ts... args)
{
    return (num - ... - args); //Binary left fold
    // Note that a binary right fold cannot be used
    // due to the lack of associativity of operator-
}

int result = removeFrom(1000, 5, 10, 15); //'result' is 1000 - 5 - 10 - 15 = 970

एक अल्पविराम पर तह

पैरामीटर पैक में प्रत्येक तत्व पर एक विशेष कार्य करने की आवश्यकता है यह एक सामान्य ऑपरेशन है। C ++ 11 के साथ, सबसे अच्छा हम कर सकते हैं:

template <class... Ts>
void print_all(std::ostream& os, Ts const&... args) {
    using expander = int[];
    (void)expander{0,
        (void(os << args), 0)...
    };
}

लेकिन एक गुना अभिव्यक्ति के साथ, ऊपर अच्छी तरह से सरल है:

template <class... Ts>
void print_all(std::ostream& os, Ts const&... args) {
    (void(os << args), ...);
}

कोई गुप्त बायलरप्लेट आवश्यक नहीं है।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow