ความแตกต่างระหว่าง std :: result_of และ Decltype

Question 1

ฉันมีปัญหาในการทำความเข้าใจความจำเป็นstd::result_ofใน C ++ 0x ถ้าฉันเข้าใจถูกต้องresult_ofใช้เพื่อรับชนิดผลลัพธ์ของการเรียกใช้อ็อบเจ็กต์ฟังก์ชันด้วยพารามิเตอร์บางประเภท ตัวอย่างเช่น:

template <typename F, typename Arg>
typename std::result_of<F(Arg)>::type
invoke(F f, Arg a)
{
    return f(a);
}

ฉันไม่เห็นความแตกต่างกับรหัสต่อไปนี้:

template <typename F, typename Arg>
auto invoke(F f, Arg a) -> decltype(f(a)) //uses the f parameter
{
    return f(a);
}

หรือ

template <typename F, typename Arg>
auto invoke(F f, Arg a) -> decltype(F()(a)); //"constructs" an F
{
    return f(a);
}

ปัญหาเดียวที่ฉันเห็นจากสองวิธีนี้คือเราต้องทำอย่างใดอย่างหนึ่ง:

มีอินสแตนซ์ของ functor เพื่อใช้ในนิพจน์ที่ส่งผ่านไปยังเดสก์ไทป์
รู้จักตัวสร้างที่กำหนดไว้สำหรับ functor

ฉันคิดถูกไหมว่าความแตกต่างเพียงอย่างเดียวระหว่างdecltypeและresult_ofข้อแรกต้องการนิพจน์ในขณะที่ข้อที่สองไม่ต้องการ?

Question 2

result_ofได้รับการแนะนำใน Boostและรวมอยู่ใน TR1และสุดท้ายใน C ++ 0x จึงresult_ofมีข้อได้เปรียบที่เข้ากันได้แบบย้อนหลัง (มีไลบรารีที่เหมาะสม).

decltype เป็นสิ่งใหม่ทั้งหมดใน C ++ 0x ไม่ได้ จำกัด เฉพาะการส่งคืนประเภทของฟังก์ชันและเป็นคุณลักษณะของภาษา

อย่างไรก็ตามบน gcc 4.5 result_ofถูกนำไปใช้ในแง่ของdecltype:

  template<typename _Signature>
    class result_of;

  template<typename _Functor, typename... _ArgTypes>
    struct result_of<_Functor(_ArgTypes...)>
    {
      typedef
        decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
        type;
    };

Question 3

หากคุณต้องการประเภทของสิ่งที่ไม่ใช่การเรียกใช้ฟังก์ชันstd::result_ofก็ไม่ต้องใช้ decltype()สามารถระบุประเภทของนิพจน์ใดก็ได้

หากเรา จำกัด ตัวเองเพียงวิธีต่างๆในการกำหนดประเภทการส่งคืนของการเรียกใช้ฟังก์ชัน (ระหว่างstd::result_of_t<F(Args...)>และdecltype(std::declval<F>()(std::declval<Args>()...)) ก็จะมีความแตกต่าง

std::result_of<F(Args...) ถูกกำหนดให้เป็น:

ถ้านิพจน์ INVOKE (declval<Fn>(), declval<ArgTypes>()...)ถูกสร้างขึ้นอย่างดีเมื่อถือว่าเป็นตัวถูกดำเนินการที่ไม่ได้ประเมิน (ข้อ 5) ประเภทสมาชิกจะตั้งชื่อประเภทเป็นdecltype(INVOKE (declval<Fn>(), declval<ArgTypes>()...)); อย่างอื่นจะไม่มีประเภทสมาชิก

ความแตกต่างระหว่างresult_of<F(Args..)>::typeและdecltype(std::declval<F>()(std::declval<Args>()...)เป็นข้อมูลเกี่ยวกับสิ่งINVOKEนั้น การใช้declval/ decltypeโดยตรงนอกจากจะพิมพ์ได้นานขึ้นเล็กน้อยแล้วจะใช้ได้Fก็ต่อเมื่อสามารถเรียกใช้ได้โดยตรงเท่านั้น (ประเภทอ็อบเจ็กต์ฟังก์ชันหรือฟังก์ชันหรือตัวชี้ฟังก์ชัน) result_ofนอกจากนี้ยังสนับสนุนตัวชี้ไปยังฟังก์ชันสมาชิกและตัวชี้ไปยังข้อมูลสมาชิก

ในขั้นต้นการใช้declval/ decltypeรับประกันนิพจน์ที่เป็นมิตรกับ SFINAE ในขณะที่std::result_ofอาจทำให้คุณเกิดข้อผิดพลาดอย่างหนักแทนการหักล้มเหลว ที่ได้รับการแก้ไขใน C ++ 14: std::result_ofตอนนี้จำเป็นต้องเป็นมิตรกับ SFINAE (ขอบคุณเอกสารนี้ )

ดังนั้นในคอมไพเลอร์ C ++ 14 ที่สอดคล้องกันstd::result_of_t<F(Args...)>นั้นเหนือกว่าอย่างเคร่งครัด มันชัดเจนสั้นและถูกต้อง^†สนับสนุนเพิ่มเติมFs ‡

^†เว้นแต่ว่าคุณกำลังใช้มันในบริบทที่คุณไม่ต้องการให้ตัวชี้แก่สมาชิกดังนั้นstd::result_of_tจะประสบความสำเร็จในกรณีที่คุณอาจต้องการให้มันล้มเหลว

^‡มีข้อยกเว้น ในขณะที่มันสนับสนุนตัวชี้ไปยังสมาชิกresult_ofจะไม่ทำงานหากคุณพยายามที่จะยกตัวอย่างที่ไม่ถูกต้องประเภท-ID สิ่งเหล่านี้จะรวมถึงฟังก์ชันที่ส่งคืนฟังก์ชันหรือประเภทนามธรรมตามค่า เช่น:

template <class F, class R = result_of_t<F()>>
R call(F& f) { return f(); }

int answer() { return 42; }

call(answer); // nope

การใช้งานที่ถูกต้องจะได้รับแต่นั่นคือรายละเอียดที่คุณไม่ต้องจำไว้ด้วยresult_of_t<F&()>decltype