C++
std :: function: कॉल करने योग्य किसी भी तत्व को लपेटने के लिए

सरल उपयोग

#include <iostream>
#include <functional>
std::function<void(int , const std::string&)> myFuncObj;
void theFunc(int i, const std::string& s)
{
    std::cout << s << ": " << i << std::endl;
}
int main(int argc, char *argv[])
{
    myFuncObj = theFunc;
    myFuncObj(10, "hello world");
}

std :: std के साथ प्रयोग किया जाने वाला फ़ंक्शन :: बाइंड

ऐसी स्थिति के बारे में सोचें जहां हमें तर्कों के साथ एक फ़ंक्शन को कॉलबैक करने की आवश्यकता है। std::function साथ प्रयोग किया जाने वाला std::function std::bind बहुत शक्तिशाली डिजाइन निर्माण देता है जैसा कि नीचे दिखाया गया है।

class A
{
public:
    std::function<void(int, const std::string&)> m_CbFunc = nullptr;
    void foo()
    {
        if (m_CbFunc)
        {
            m_CbFunc(100, "event fired");
        }
    }

};

class B
{
public:
    B()
    {
        auto aFunc = std::bind(&B::eventHandler, this, std::placeholders::_1, std::placeholders::_2);
        anObjA.m_CbFunc = aFunc;
    }
    void eventHandler(int i, const std::string& s)
    {
        std::cout << s << ": " << i << std::endl;
    }

    void DoSomethingOnA()
    {
        anObjA.foo();
    }

    A anObjA;
};

int main(int argc, char *argv[])
{
     B anObjB;
     anObjB.DoSomethingOnA();
}

std :: lambda और std :: bind के साथ कार्य करता है

#include <iostream>
#include <functional>

using std::placeholders::_1; // to be used in std::bind example

int stdf_foobar (int x, std::function<int(int)> moo)
{
    return x + moo(x); // std::function moo called
}

int foo (int x) { return 2+x; }

int foo_2 (int x, int y) { return 9*x + y; }

int main()
{
    int a = 2;

    /* Function pointers */
    std::cout << stdf_foobar(a, &foo) << std::endl; // 6 ( 2 + (2+2) )
    // can also be: stdf_foobar(2, foo)

    /* Lambda expressions */
    /* An unnamed closure from a lambda expression can be
     * stored in a std::function object:
     */
    int capture_value = 3;
    std::cout << stdf_foobar(a,
                             [capture_value](int param) -> int { return 7 + capture_value * param; })
              << std::endl;
    // result: 15 ==  value + (7 * capture_value * value) == 2 + (7 + 3 * 2)

    /* std::bind expressions */
    /* The result of a std::bind expression can be passed.
     * For example by binding parameters to a function pointer call:
     */    
    int b = stdf_foobar(a, std::bind(foo_2, _1, 3));
    std::cout << b << std::endl;
    // b == 23 == 2 + ( 9*2 + 3 )
    int c = stdf_foobar(a, std::bind(foo_2, 5, _1));
    std::cout << c << std::endl;
    // c == 49 == 2 + ( 9*5 + 2 )

    return 0;
}

`फ़ंक्शन` ओवरहेड

std::function महत्वपूर्ण ओवरहेड का कारण बन सकता है। क्योंकि std::function में [value semantics] [1] है, यह दिए गए callable को स्वयं कॉपी या स्थानांतरित करना चाहिए। लेकिन चूंकि यह एक मनमाना प्रकार के कॉलबल्स ले सकता है, इसलिए इसे करने के लिए अक्सर गतिशील रूप से मेमोरी आवंटित करनी होगी।

कुछ function कार्यान्वयन को तथाकथित "छोटी वस्तु अनुकूलन" कहा जाता है, जहां छोटे प्रकार (जैसे फ़ंक्शन पॉइंटर्स, सदस्य पॉइंटर्स, या बहुत कम अवस्था वाले function ) को सीधे function ऑब्जेक्ट में संग्रहीत किया जाएगा। लेकिन यहां तक कि यह केवल तभी काम करता है जब टाइप noexcept मूव रचनात्मक हो। इसके अलावा, C ++ मानक की आवश्यकता नहीं है कि सभी कार्यान्वयन एक प्रदान करते हैं।

निम्नलिखित को धयान मे रखते हुए:

//Header file
using MyPredicate = std::function<bool(const MyValue &, const MyValue &)>;

void SortMyContainer(MyContainer &C, const MyPredicate &pred);

//Source file
void SortMyContainer(MyContainer &C, const MyPredicate &pred)
{
    std::sort(C.begin(), C.end(), pred);
}

एक टेम्पलेट पैरामीटर SortMyContainer लिए पसंदीदा समाधान होगा, लेकिन हमें यह मान लेना चाहिए कि यह किसी भी कारण से संभव या वांछनीय नहीं है। SortMyContainer दुकान की जरूरत नहीं है pred अपने स्वयं के कॉल से परे है। और फिर भी, pred अच्छी तरह से स्मृति को आबंटित कर सकते हैं यदि functor यह करने के लिए दिया कुछ गैर तुच्छ आकार की है।

function मेमोरी को आवंटित करता है क्योंकि इसे कॉपी / स्थानांतरित करने के लिए कुछ की आवश्यकता होती है; function कॉल करने योग्य का स्वामित्व लेता है जो इसे दिया गया है। लेकिन SortMyContainer प्रतिदेय खुद की जरूरत नहीं है; यह सिर्फ इसका संदर्भ है। इसलिए यहां function का उपयोग function ओवरकिल है; यह कुशल हो सकता है, लेकिन यह नहीं हो सकता है।

कोई मानक लाइब्रेरी फ़ंक्शन प्रकार नहीं है जो केवल कॉल करने योग्य का संदर्भ देता है। तो एक वैकल्पिक समाधान ढूंढना होगा, या आप ओवरहेड के साथ रहना चुन सकते हैं।

साथ ही, function पास यह नियंत्रित करने के लिए कोई प्रभावी साधन नहीं है कि ऑब्जेक्ट के लिए मेमोरी आवंटन कहां से आते हैं। हां, इसके निर्माणकर्ता हैं जो एक allocator लेते हैं, लेकिन [कई कार्यान्वयन उन्हें सही ढंग से लागू नहीं करते हैं ... या बिल्कुल भी] [2]।

किसी function को कॉल करना सामग्री को सीधे कॉल करने की तुलना में धीमा है। चूंकि कोई भी function इंस्टेंस किसी भी कॉल करने योग्य हो सकता है, इसलिए function माध्यम से कॉल अप्रत्यक्ष होना चाहिए। कॉलिंग function का ओवरहेड एक वर्चुअल फ़ंक्शन कॉल के आदेश पर होता है।

बंधन std :: एक अलग कॉल करने योग्य प्रकारों के लिए कार्य करता है

/*
 * This example show some ways of using std::function to call
 *  a) C-like function
 *  b) class-member function
 *  c) operator()
 *  d) lambda function
 *
 * Function call can be made:
 *  a) with right arguments
 *  b) argumens with different order, types and count
 */
#include <iostream>
#include <functional>
#include <iostream>
#include <vector>

using std::cout;
using std::endl;
using namespace std::placeholders;



// simple function to be called
double foo_fn(int x, float y, double z)
{
  double res = x + y + z;
  std::cout << "foo_fn called with arguments: " 
            << x << ", " << y << ", " << z 
            << " result is : " << res 
            << std::endl;
  return res;
}

// structure with member function to call
struct foo_struct
{
    // member function to call
    double foo_fn(int x, float y, double z)
    {
        double res = x + y + z;
        std::cout << "foo_struct::foo_fn called with arguments: " 
                << x << ", " << y << ", " << z 
                << " result is : " << res 
                << std::endl;
        return res;
    }
    // this member function has different signature - but it can be used too
    // please not that argument order is changed too
    double foo_fn_4(int x, double z, float y, long xx)
    {
        double res = x + y + z + xx;
        std::cout << "foo_struct::foo_fn_4 called with arguments: " 
                << x << ", " << z << ", " << y << ", " << xx
                << " result is : " << res 
                << std::endl;
        return res;
    }
    // overloaded operator() makes whole object to be callable
    double operator()(int x, float y, double z)
    {
        double res = x + y + z;
        std::cout << "foo_struct::operator() called with arguments: " 
                << x << ", " << y << ", " << z 
                << " result is : " << res 
                << std::endl;
        return res;
    }
};


int main(void)
{
  // typedefs
  using function_type = std::function<double(int, float, double)>;

  // foo_struct instance
  foo_struct fs;
  
  // here we will store all binded functions 
  std::vector<function_type> bindings;

  // var #1 - you can use simple function
  function_type var1 = foo_fn;
  bindings.push_back(var1);
  
  // var #2 - you can use member function 
  function_type var2 = std::bind(&foo_struct::foo_fn, fs, _1, _2, _3);
  bindings.push_back(var2);
  
  // var #3 - you can use member function with different signature
  // foo_fn_4 has different count of arguments and types
  function_type var3 = std::bind(&foo_struct::foo_fn_4, fs, _1, _3, _2, 0l);
  bindings.push_back(var3);

  // var #4 - you can use object with overloaded operator() 
  function_type var4 = fs;
  bindings.push_back(var4);

  // var #5 - you can use lambda function
  function_type var5 = [](int x, float y, double z)
    {
        double res = x + y + z;
        std::cout << "lambda  called with arguments: " 
                << x << ", " << y << ", " << z 
                << " result is : " << res 
                << std::endl;
        return res;
    };
  bindings.push_back(var5);
    
  std::cout << "Test stored functions with arguments: x = 1, y = 2, z = 3" 
            << std::endl;
  
  for (auto f : bindings)
      f(1, 2, 3);
      
}

लाइव

आउटपुट:

Test stored functions with arguments: x = 1, y = 2, z = 3
foo_fn called with arguments: 1, 2, 3 result is : 6
foo_struct::foo_fn called with arguments: 1, 2, 3 result is : 6
foo_struct::foo_fn_4 called with arguments: 1, 3, 2, 0 result is : 6
foo_struct::operator() called with arguments: 1, 2, 3 result is : 6
lambda  called with arguments: 1, 2, 3 result is : 6

Std :: tuple में फ़ंक्शन फ़ंक्शन तर्क

कुछ कार्यक्रमों को भविष्य के कुछ फ़ंक्शन के लिए स्टोर तर्क की आवश्यकता होती है।

यह उदाहरण दिखाता है कि std :: tuple में संग्रहीत तर्कों के साथ किसी भी फ़ंक्शन को कैसे कॉल किया जाए

#include <iostream>
#include <functional>
#include <tuple>
#include <iostream>

// simple function to be called
double foo_fn(int x, float y, double z)
{
   double res =  x + y + z;
   std::cout << "foo_fn called. x = " << x << " y = " << y << " z = " << z
             << " res=" << res;
   return res;
}

// helpers for tuple unrolling
template<int ...> struct seq {};
template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};
template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };

// invocation helper 
template<typename FN, typename P, int ...S>
double call_fn_internal(const FN& fn, const P& params, const seq<S...>)
{
   return fn(std::get<S>(params) ...);
}
// call function with arguments stored in std::tuple
template<typename Ret, typename ...Args>
Ret call_fn(const std::function<Ret(Args...)>& fn, 
            const std::tuple<Args...>& params)
{
    return call_fn_internal(fn, params, typename gens<sizeof...(Args)>::type());
}


int main(void)
{
  // arguments
  std::tuple<int, float, double> t = std::make_tuple(1, 5, 10);
  // function to call
  std::function<double(int, float, double)> fn = foo_fn;
  
  // invoke a function with stored arguments
  call_fn(fn, t);
}

लाइव

आउटपुट:

foo_fn called. x = 1 y = 5 z = 10 res=16