क्या std :: function का एक स्टैंडअलोन कार्यान्वयन है?

Question

मैं एक एम्बेडेड सिस्टम पर काम कर रहा हूं, इसलिए कोड आकार एक मुद्दा है। मानक लाइब्रेरी का उपयोग करके मेरी बाइनरी आकार लगभग 60k तक, 40k से 100k तक। मैं std :: फ़ंक्शन का उपयोग करना चाहता हूं, लेकिन मैं इसे 60k के लिए उचित नहीं ठहरा सकता। क्या कोई स्टैंडअलोन कार्यान्वयन है जिसका मैं उपयोग कर सकता हूं, या कुछ ऐसा ही कर सकता हूं? मैं इसका उपयोग सी ++ में बाध्य चर के साथ सदस्य कार्यों में लम्बाडा डालने के लिए कर रहा हूं 11.

Answer 1

60k कंपाइलर द्वारा अपवाद हैंडलिंग से आया था, क्योंकि std :: function के लिए अपवादों की आवश्यकता थी। std :: फ़ंक्शन केवल एक अपवाद फेंकता है, "bad_function_call"। तो मैंने अपवाद फेंकने वाले कोड को हटा दिया, अब अगर एक खाली फ़ंक्शन कहा जाता है तो यह दोषों को रोकता है, और मैंने स्वयं को 60k बचाया।

Answer 2

यहां किसी भी शीर्षलेख को शामिल किए बिना std :: function-like class टेम्पलेट का सरल कार्यान्वयन है।

live_demo

// Scroll down for example of usage 
namespace bicycle 
{ 
    template<typename Result,typename ...Args> 
    struct abstract_function 
    { 
     virtual Result operator()(Args... args)=0; 
     virtual abstract_function *clone() const =0; 
     virtual ~abstract_function() = default; 
    }; 

    template<typename Func,typename Result,typename ...Args> 
    class concrete_function: public abstract_function<Result,Args...> 
    { 
     Func f; 
    public: 
     concrete_function(const Func &x) 
      : f(x) 
     {} 
     Result operator()(Args... args) override 
     { 
      return f(args...); 
     } 
     concrete_function *clone() const override 
     { 
      return new concrete_function{f}; 
     } 
    }; 

    template<typename Func> 
    struct func_filter 
    { 
     typedef Func type; 
    }; 
    template<typename Result,typename ...Args> 
    struct func_filter<Result(Args...)> 
    { 
     typedef Result (*type)(Args...); 
    }; 

    template<typename signature> 
    class function; 

    template<typename Result,typename ...Args> 
    class function<Result(Args...)> 
    { 
     abstract_function<Result,Args...> *f; 
    public: 
     function() 
      : f(nullptr) 
     {} 
     template<typename Func> function(const Func &x) 
      : f(new concrete_function<typename func_filter<Func>::type,Result,Args...>(x)) 
     {} 
     function(const function &rhs) 
      : f(rhs.f ? rhs.f->clone() : nullptr) 
     {} 
     function &operator=(const function &rhs) 
     { 
      if((&rhs != this) && (rhs.f)) 
      { 
       auto *temp = rhs.f->clone(); 
       delete f; 
       f = temp; 
      } 
      return *this; 
     } 
     template<typename Func> function &operator=(const Func &x) 
     { 
      auto *temp = new concrete_function<typename func_filter<Func>::type,Result,Args...>(x); 
      delete f; 
      f = temp; 
      return *this; 
     } 
     Result operator()(Args... args) 
     { 
      if(f) 
       return (*f)(args...); 
      else 
       return Result{}; 
     } 
     ~function() 
     { 
      delete f; 
     } 
    }; 
} 

// ___________________[ Example of usage ]___________________ // 

int func1(double) 
{ 
    return 1; 
} 
struct Functor2 
{ 
    int operator()(double) 
    { 
     return 2; 
    } 
}; 

double func3(bool,int) 
{ 
    return 3.0; 
} 
struct Functor4 
{ 
    double operator()(bool,int) 
    { 
     return 4.0; 
    } 
}; 

int main() 
{ 
    int res = 10; 
    { 
     bicycle::function<int(double)> f{func1}; 

     res -= f(1.0); 
     f = Functor2{}; 
     res -= f(2.0); 
    } 
    { 
     bicycle::function<double(bool,int)> f1; 
     f1 = func3; 

     bicycle::function<double(bool,int)> f2{f1}; 
     res -= f2(true,1); 

     f1 = Functor4{}; 
     f2 = f1; 
     res -= f2(false,2); 
    } 
    return res; 
}