ทำไมคอมไพเลอร์สามารถปรับแต่งแลมบ์ดาได้ดีกว่าฟังก์ชั่นธรรมดา?

ในหนังสือของเขาThe C++ Standard Library (Second Edition)Nicolai Josuttis ระบุว่า lambdas สามารถปรับให้เหมาะสมโดยคอมไพเลอร์มากกว่าฟังก์ชั่นธรรมดา

นอกจากนี้คอมไพเลอร์ C ++ เพิ่มประสิทธิภาพ lambdas ได้ดีกว่าฟังก์ชั่นทั่วไป (หน้า 213)

ทำไมถึงเป็นอย่างนั้น?

ฉันคิดว่าเมื่อพูดถึงการอินไลน์ก็ไม่น่าจะมีความแตกต่างอีกต่อไป เหตุผลเดียวที่ฉันคิดได้ก็คือคอมไพเลอร์อาจมีบริบทท้องถิ่นที่ดีขึ้นกับลูกแกะและสิ่งเหล่านี้สามารถทำให้สมมติฐานมากขึ้นและดำเนินการเพิ่มประสิทธิภาพมากขึ้น

เหตุผลก็คือ lambdas เป็นวัตถุของฟังก์ชั่นดังนั้นการส่งผ่านไปยังเทมเพลตของฟังก์ชันจะยกตัวอย่างฟังก์ชันใหม่สำหรับวัตถุนั้นโดยเฉพาะ คอมไพเลอร์สามารถ inline โทรแลมบ์เล็กน้อย

สำหรับฟังก์ชั่นในทางกลับกันข้อแม้เก่าใช้: ตัวชี้ฟังก์ชั่นได้รับการส่งผ่านไปยังแม่แบบฟังก์ชั่นและคอมไพเลอร์แบบดั้งเดิมมีปัญหามากมายในการโทรผ่านตัวชี้ฟังก์ชั่น พวกมันสามารถอนุมานตามทฤษฎีได้ แต่ถ้าฟังก์ชันรอบข้างถูกอินไลน์เช่นกัน

เป็นตัวอย่างพิจารณาแม่แบบฟังก์ชั่นต่อไปนี้:

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 ()และสามารถโทรแบบอินไลน์ได้เล็กน้อย (และเรียกใช้ฟังก์ชัน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เป็นฟังก์ชันหนึ่งได้

เพราะเมื่อคุณผ่าน "ฟังก์ชั่น" ไปยังอัลกอริทึมคุณจะผ่านตัวชี้ไปยังฟังก์ชั่นดังนั้นจึงต้องทำการโทรทางอ้อมผ่านตัวชี้ไปยังฟังก์ชั่น เมื่อคุณใช้แลมบ์ดาคุณกำลังส่งวัตถุไปยังอินสแตนซ์เทมเพลตที่อินสแตนซ์เป็นพิเศษสำหรับประเภทนั้นและการเรียกฟังก์ชั่นแลมบ์ดาเป็นการโทรโดยตรงไม่ใช่การโทรผ่านตัวชี้ฟังก์ชันเพื่อให้มีแนวโน้มมากขึ้น