C++
कॉल करने योग्य वस्तुएँ

परिचय

टिप्पणियों

कार्य बिंदु

फ़ंक्शन पॉइंटर्स पासिंग फ़ंक्शन का सबसे बुनियादी तरीका है, जिसका उपयोग सी में भी किया जा सकता है (अधिक विवरण के लिए सी प्रलेखन देखें)।

कॉल करने योग्य वस्तुओं के उद्देश्य के लिए, एक फ़ंक्शन पॉइंटर को इस प्रकार परिभाषित किया जा सकता है:

typedef returnType(*name)(arguments);                       // All
using name = returnType(*)(arguments);                      // <= C++11
using name = std::add_pointer<returnType(arguments)>::type; // <= C++11
using name = std::add_pointer_t<returnType(arguments)>;     // <= C++14

यदि हम अपने स्वयं के वेक्टर प्रकार लिखने के लिए एक फ़ंक्शन पॉइंटर का उपयोग कर रहे हैं, तो यह ऐसा दिखेगा:

using LessThanFunctionPtr = std::add_pointer_t<bool(int, int)>;
void sortVectorInt(std::vector<int>&v, LessThanFunctionPtr lessThan) {
    if (v.size() < 2)
        return;
    if (v.size() == 2) {
        if (!lessThan(v.front(), v.back())) // Invoke the function pointer
            std::swap(v.front(), v.back());
        return;
    }
    std::sort(v, lessThan);
}

bool lessThanInt(int lhs, int rhs) { return lhs < rhs; }
sortVectorInt(vectorOfInt, lessThanInt); // Passes the pointer to a free function

struct GreaterThanInt {
   static bool cmp(int lhs, int rhs) { return lhs > rhs; }
};
sortVectorInt(vectorOfInt, &GreaterThanInt::cmp); // Passes the pointer to a static member function

वैकल्पिक रूप से, हम फ़ंक्शन पॉइंटर को निम्न तरीकों में से एक के रूप में लागू कर सकते हैं:

• (*lessThan)(v.front(), v.back()) // All
• std::invoke(lessThan, v.front(), v.back()) // <= C++17

ऑपरेटर के साथ कक्षाएं () (फ़नकार)

प्रत्येक वर्ग जो operator() ओवरलोड करता operator() को एक फ़ंक्शन ऑब्जेक्ट के रूप में उपयोग किया जा सकता है। इन कक्षाओं को हाथ से लिखा जा सकता है (अक्सर फंक्शनलर्स के रूप में संदर्भित) या कंपाइलर द्वारा स्वचालित रूप से लैम्बडास को C ++ 11 से लिखकर उत्पन्न किया जाता है।

struct Person {
    std::string name;
    unsigned int age;
};

// Functor which find a person by name
struct FindPersonByName {
    FindPersonByName(const std::string &name) : _name(name) {}

    // Overloaded method which will get called
    bool operator()(const Person &person) const {
         return person.name == _name;
    }
private:
    std::string _name;
};

std::vector<Person> v; // Assume this contains data
std::vector<Person>::iterator iFind =
    std::find_if(v.begin(), v.end(), FindPersonByName("Foobar"));
// ...

जैसा कि फंक्शनलर्स की अपनी पहचान होती है, उन्हें टाइप टाइप में नहीं रखा जा सकता है और इन्हें टेम्प्लेट तर्क के माध्यम से स्वीकार करना होगा। std::find_if की परिभाषा std::find_if जैसी दिख सकती है:

template<typename Iterator, typename Predicate>
Iterator find_if(Iterator begin, Iterator end, Predicate &predicate) {
     for (Iterator i = begin, i != end, ++i)
         if (predicate(*i))
             return i;
     return end;
}

C ++ 17 से, विधेय की कॉल आह्वान के साथ की जा सकती है: std::invoke(predicate, *i) ।