কারণটি হ'ল ল্যাম্বডাস ফাংশন অবজেক্টস তাই কোনও ফাংশন টেমপ্লেটে এগুলি প্রেরণ করা সেই বস্তুর জন্য বিশেষত একটি নতুন ফাংশন ইনস্ট্যান্ট করবে। সংকলক এভাবে তুচ্ছভাবে ল্যাম্বডা কলটিকে ইনলাইন করতে পারে।
অন্যদিকে ফাংশনগুলির জন্য, পুরানো ক্যাভিয়েট প্রযোজ্য: ফাংশন পয়েন্টারটি ফাংশন টেম্পলেটটিতে পৌঁছে যায় এবং সংযোজকরা traditionতিহ্যগতভাবে ফাংশন পয়েন্টারগুলির মাধ্যমে কলগুলি ইনলাইনেনে প্রচুর সমস্যা করে। এগুলি তাত্ত্বিকভাবে অন্তর্ভুক্ত করা যেতে পারে তবে কেবল পার্শ্ববর্তী ফাংশনটিও যদি ইনলাইন করা থাকে তবে।
উদাহরণ হিসাবে, নিম্নলিখিত ফাংশন টেম্পলেট বিবেচনা করুন:
template <typename Iter, typename F>
void map(Iter begin, Iter end, F f) {
for (; begin != end; ++begin)
*begin = f(*begin);
}
এটিকে এভাবে ল্যাম্বডা দিয়ে কল করা:
int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });
এই ইনস্ট্যান্টেশন ফলাফল (সংকলক দ্বারা নির্মিত):
template <>
void map<int*, _some_lambda_type>(int* begin, int* end, _some_lambda_type f) {
for (; begin != end; ++begin)
*begin = f.operator()(*begin);
}
… সংকলক জানে _some_lambda_type::operator ()
এবং এগুলিকে তুচ্ছভাবে কল করতে পারে line (এবং অন্য কোনও ল্যাম্বডারের map
সাথে ফাংশনটি আহ্বান করা একটি নতুন ইনস্ট্যান্টেশন তৈরি করবে যেহেতু প্রতিটি ল্যাম্বডায় একটি আলাদা ধরণের রয়েছে))map
তবে যখন ফাংশন পয়েন্টার দিয়ে ডাকা হয় তখন ইনস্ট্যান্টেশনটি নিম্নরূপ দেখায়:
template <>
void map<int*, int (*)(int)>(int* begin, int* end, int (*f)(int)) {
for (; begin != end; ++begin)
*begin = f(*begin);
}
… এবং এখানে f
প্রতিটি কলের জন্য পৃথক ঠিকানার দিকে ইঙ্গিত করে map
এবং এভাবে সংকলক f
আশেপাশের map
কলটিও ইনলাইন না করা পর্যন্ত কলগুলিতে ইনলাইন করতে পারে না যাতে সংকলকটি f
একটি নির্দিষ্ট ফাংশনে সমাধান করতে পারে।