সংক্ষেপে,std::function আপনার না করার কারণ না থাকলে ব্যবহার করুন।
ফাংশন পয়েন্টারগুলির কিছু প্রসঙ্গ ক্যাপচার করতে না পারার অসুবিধা রয়েছে । আপনি উদাহরণস্বরূপ একটি কলব্যাক হিসাবে ল্যাম্বডা ফাংশনটি পাস করতে সক্ষম হবেন না যা কিছু প্রসঙ্গের ভেরিয়েবলকে ক্যাপচার করে (তবে এটি কোনওটি ক্যাপচার না করলে এটি কাজ করবে)। কোনও অবজেক্টের সদস্যকে পরিবর্তনশীল (যেমন অ-স্থিতিশীল) কল করাও সম্ভব নয়, যেহেতু বস্তু ( this-পয়েন্টার) ক্যাপচার করা দরকার। (1)
std::function(যেহেতু সি ++ 11) মূলত কোনও ফাংশন সংরক্ষণ করা হয় (এটি পাস করার পরে এটি সংরক্ষণ করার প্রয়োজন হয় না)। সুতরাং আপনি যদি কোনও সদস্যের পরিবর্তনশীল হিসাবে উদাহরণস্বরূপ কলব্যাক সঞ্চয় করতে চান তবে এটি সম্ভবত আপনার সেরা পছন্দ। তবে আপনি যদি এটি সংরক্ষণ না করেন তবে এটি একটি "প্রথম পছন্দ" যদিও এটি ডাকা হওয়ার সময় কিছু (খুব ছোট) ওভারহেড চালু করার অসুবিধা রয়েছে (সুতরাং খুব কার্য সম্পাদন-সমালোচনামূলক পরিস্থিতিতে এটি সমস্যা হতে পারে তবে বেশিরভাগ ক্ষেত্রে) এটা করা উচিত নয়)। এটি অত্যন্ত "সর্বজনীন": আপনি যদি সামঞ্জস্যপূর্ণ এবং পঠনযোগ্য কোড সম্পর্কে প্রচুর যত্ন নেন এবং পাশাপাশি আপনার প্রতিটি পছন্দ (যেমন এটি সহজ রাখতে চান) সম্পর্কে চিন্তা করতে না চান তবে std::functionআপনার চারপাশের প্রতিটি ফাংশনের জন্য ব্যবহার করুন ।
তৃতীয় বিকল্পের বিষয়ে চিন্তা করুন: আপনি যদি একটি ছোট ফাংশন প্রয়োগ করতে চলেছেন যা প্রদত্ত কলব্যাক ফাংশনটির মাধ্যমে কিছু রিপোর্ট করে, একটি টেম্পলেট প্যারামিটার বিবেচনা করুন , যা কোনও কলযোগ্য বস্তু , যেমন একটি ফাংশন পয়েন্টার, একটি ফান্টেক্টর, ল্যাম্বদা হতে পারে , a std::function, ... এখানে ড্রব্যাকটি হ'ল আপনার (বাহ্যিক) ফাংশনটি একটি টেম্পলেট হয়ে যায় এবং তাই শিরোনামে প্রয়োগ করা দরকার। অন্যদিকে আপনি সুবিধাটি পান যে কলব্যাকের সাথে কলটি ইনলাইন করা যায়, কারণ আপনার (বাহ্যিক) ফাংশনের ক্লায়েন্ট কোড কলকে "কল্পনা করে" কল দেয় যে সঠিক টাইপের তথ্য উপলব্ধ।
টেমপ্লেট প্যারামিটার সহ সংস্করণের উদাহরণ ( প্রি-সি ++ এর &পরিবর্তে লিখুন &&):
template <typename CallbackFunction>
void myFunction(..., CallbackFunction && callback) {
...
callback(...);
...
}
আপনি যেমন নীচের টেবিলটিতে দেখতে পাচ্ছেন, তাদের সবারই রয়েছে তাদের সুবিধা এবং অসুবিধা:
+-------------------+--------------+---------------+----------------+
| | function ptr | std::function | template param |
+===================+==============+===============+================+
| can capture | no(1) | yes | yes |
| context variables | | | |
+-------------------+--------------+---------------+----------------+
| no call overhead | yes | no | yes |
| (see comments) | | | |
+-------------------+--------------+---------------+----------------+
| can be inlined | no | no | yes |
| (see comments) | | | |
+-------------------+--------------+---------------+----------------+
| can be stored | yes | yes | no(2) |
| in class member | | | |
+-------------------+--------------+---------------+----------------+
| can be implemented| yes | yes | no |
| outside of header | | | |
+-------------------+--------------+---------------+----------------+
| supported without | yes | no(3) | yes |
| C++11 standard | | | |
+-------------------+--------------+---------------+----------------+
| nicely readable | no | yes | (yes) |
| (my opinion) | (ugly type) | | |
+-------------------+--------------+---------------+----------------+
(1) এই সীমাবদ্ধতা কাটিয়ে ওঠার জন্য ওয়ার্কআরউন্ডগুলি বিদ্যমান রয়েছে, উদাহরণস্বরূপ আপনার (বাহ্যিক) ফাংশনে আরও পরামিতি হিসাবে অতিরিক্ত ডেটা পাস করা: myFunction(..., callback, data)কল করবে callback(data)। এটি সি-স্টাইলের "আর্গুমেন্টগুলির সাথে কলব্যাক", যা সি ++ এ সম্ভব (এবং যেভাবে ডাব্লুআইএন 32 এপিআইতে ব্যবহৃত হয়েছিল) তবে তা এড়ানো উচিত কারণ আমাদের সি ++ তে আরও ভাল বিকল্প রয়েছে।
(২) যদি না আমরা কোনও ক্লাস টেম্পলেট, অর্থাৎ যে ক্লাসে আপনি ফাংশনটি সঞ্চয় করে থাকি সে সম্পর্কে কথা বলি। তবে এর অর্থ হ'ল ক্লায়েন্টের পক্ষ থেকে ফাংশনের ধরণটি সেই বস্তুর ধরণের সিদ্ধান্ত নেয় যা কলব্যাক সংরক্ষণ করে, যা প্রকৃত ব্যবহারের ক্ষেত্রে প্রায়শই কোনও বিকল্প নয়।
(3) প্রাক-সি ++ 11 এর জন্য ব্যবহার করুন boost::function