ইতিমধ্যে অনেক ভাল উত্তর আছে, তাই আমার আপনার প্রশ্নের একটি উপসেট সম্বোধন করবে; যেমন, আমি আপনার প্রশ্নের ভিত্তিতে ছাতা নিই, কারণ ওওপি এবং কার্যকরী বৈশিষ্ট্যগুলি পারস্পরিক একচেটিয়া নয়।
আপনি যদি সি ++ 11 ব্যবহার করেন তবে ভাষা / স্ট্যান্ডার্ড লাইব্রেরিতে এই ধরণের অনেকগুলি ফাংশনাল-প্রোগ্রামিং বৈশিষ্ট্য রয়েছে যা ওওপি-র সাথে ভালভাবে সমন্বয়সাধন করে (বেশ সুন্দর)। অবশ্যই, আমি নিশ্চিত না যে আপনার মনিব বা সহকর্মীদের দ্বারা টিএমপি কতটা ভাল পাবেন। তবে মূল বিষয়টি হ'ল আপনি এই বৈশিষ্ট্যগুলির মধ্যে অনেকগুলি সি -++ এর মতো কোনও রূপে বা অন্য কোনও রূপে পেতে পারেন।
সংকলনের সময় পুনরাবৃত্তি সহ টেম্পলেটগুলি ব্যবহার করা আপনার প্রথম 3 পয়েন্টের উপর নির্ভর করে,
- অপরিবর্তনীয়তা
- recursion
- প্যাটার্ন ম্যাচিং
সেই টেম্পলেটটিতে মানগুলি অপরিবর্তনীয় (সংকলন-সময় ধ্রুবক) হয়, যে কোনও পুনরাবৃত্তি পুনরাবৃত্তি ব্যবহার করে করা হয়, এবং ওভারলোড রেজোলিউশনের আকারে ব্রাঞ্চিং (আরও বা কম) প্যাটার্ন ম্যাচিং ব্যবহার করে করা হয়।
অন্যান্য পয়েন্ট হিসাবে, ব্যবহার std::bind
এবং std::function
আপনাকে আংশিক ফাংশন অ্যাপ্লিকেশন দেয় এবং ফাংশন পয়েন্টার ভাষা অন্তর্নির্মিত হয়। কলযোগ্য বস্তুগুলি হ'ল কার্যকরী বস্তু (পাশাপাশি আংশিক ফাংশন অ্যাপ্লিকেশন)। নোট করুন যে কলযোগ্য বস্তুর দ্বারা, আমি এর অর্থ যা তাদের সংজ্ঞায়িত করে operator ()
।
অলস মূল্যায়ন এবং খাঁটি ফাংশনগুলি কিছুটা কঠিন হবে; খাঁটি ফাংশনগুলির জন্য, আপনি ল্যাম্বদা ফাংশনগুলি ব্যবহার করতে পারেন যা কেবল মান অনুসারে ক্যাপচার করে তবে এটি আদর্শ নয়।
শেষ অবধি, আংশিক ফাংশন অ্যাপ্লিকেশন সহ সংকলন-সময় পুনরাবৃত্তি ব্যবহার করার একটি উদাহরণ এখানে। এটি কিছুটা সংশ্লেষিত উদাহরণ, তবে এটি উপরের পয়েন্টগুলির বেশিরভাগ ক্ষেত্রে প্রদর্শিত করে। এটি একটি প্রদত্ত ফাংশনে প্রদত্ত টিপলটিতে মানগুলি পুনরাবৃত্তভাবে আবদ্ধ করবে এবং একটি (কলযোগ্য) ফাংশন অবজেক্ট তৈরি করবে
#include <iostream>
#include <functional>
//holds a compile-time index sequence
template<std::size_t ... >
struct index_seq
{};
//builds the index_seq<...> struct with the indices (boils down to compile-time indexing)
template<std::size_t N, std::size_t ... Seq>
struct gen_indices
: gen_indices<N-1, N-1, Seq ... >
{};
template<std::size_t ... Seq>
struct gen_indices<0, Seq ... >
{
typedef index_seq<Seq ... > type;
};
template <typename RType>
struct bind_to_fcn
{
template <class Fcn, class ... Args>
std::function<RType()> fcn_bind(Fcn fcn, std::tuple<Args...> params)
{
return bindFunc(typename gen_indices<sizeof...(Args)>::type(), fcn, params);
}
template<std::size_t ... Seq, class Fcn, class ... Args>
std::function<RType()> bindFunc(index_seq<Seq...>, Fcn fcn, std::tuple<Args...> params)
{
return std::bind(fcn, std::get<Seq>(params) ...);
}
};
//some arbitrary testing function to use
double foo(int x, float y, double z)
{
return x + y + z;
}
int main(void)
{
//some tuple of parameters to use in the function call
std::tuple<int, float, double> t = std::make_tuple(1, 2.04, 0.1);
typedef double(*SumFcn)(int,float,double);
bind_to_fcn<double> binder;
auto other_fcn_obj = binder.fcn_bind<SumFcn>(foo, t);
std::cout << other_fcn_obj() << std::endl;
}