Std :: result_of ve decltype arasındaki fark

std::result_ofC ++ 0x'in ihtiyacını anlamakta biraz sorun yaşıyorum . Doğru anladıysam, result_ofbelirli türde parametrelerle bir işlev nesnesini çağırmanın sonuç türünü elde etmek için kullanılır. Örneğin:

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

Aşağıdaki kodla farkı gerçekten görmüyorum:

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

veya

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

Bu iki çözümde görebildiğim tek sorun şudur:

• decltype'a iletilen ifadede kullanmak için bir functor örneğine sahip olun.
• functor için tanımlı bir kurucu bilir.

Ben arasındaki tek fark bu doğru düşünme mıyım decltypeve result_ofikinci bunu yapmaz İlki bir ifade ihtiyacı var?

result_ofBoost'ta tanıtıldı ve ardından TR1'e ve son olarak C ++ 0x'e dahil edildi. Bu nedenle result_ofgeriye dönük uyumlu (uygun bir kitaplıkla) bir avantajı vardır.

decltype C ++ 0x'de tamamen yeni bir şeydir, yalnızca bir işlevin türünü döndürmekle sınırlandırmaz ve bir dil özelliğidir.

Her neyse, gcc 4.5'te result_ofşu şekilde uygulanır 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;
    };

İşlev çağrısı gibi olmayan bir şeye ihtiyacınız varsa std::result_of, bu geçerli değildir. decltype()size herhangi bir ifadenin türünü verebilir.

Kendimizi bir işlev çağrısının dönüş türünü ( std::result_of_t<F(Args...)>ve arasında decltype(std::declval<F>()(std::declval<Args>()...)) belirlemenin farklı yollarıyla sınırlarsak , o zaman bir fark vardır.

std::result_of<F(Args...) olarak tanımlanır:

İfade INVOKE (declval<Fn>(), declval<ArgTypes>()...), değerlendirilmemiş bir işlenen olarak ele alındığında (Madde 5) iyi biçimlendirilmişse, üye typedef türü, türü decltype(INVOKE (declval<Fn>(), declval<ArgTypes>()...)); başka şekilde adlandırır, üye türü olmaz.

Arasındaki fark result_of<F(Args..)>::typeve decltype(std::declval<F>()(std::declval<Args>()...)hepsi hakkında INVOKE. Yazmak için biraz daha uzun olmasına ek olarak declval/ decltypedoğrudan kullanmak , yalnızca Fdoğrudan çağrılabilirse geçerlidir (bir işlev nesnesi türü veya bir işlev veya bir işlev işaretçisi). result_ofayrıca üye işlevlerine işaretçileri ve üye verilerine işaretçileri destekler.

Başlangıçta, SFINAE dostu bir ifadeyi kullanmak declval/ decltypegarantilemek, std::result_ofkesinti hatası yerine size sert bir hata verebilir. Bu C ++ 14'te düzeltildi: std::result_ofartık SFINAE dostu olması gerekiyor ( bu makale sayesinde ).

Dolayısıyla uyumlu bir C ++ 14 derleyicisinde, std::result_of_t<F(Args...)>kesinlikle üstündür. Daha net, daha kısa ve doğru bir şekilde ^† daha fazla Fs ^‡ destekliyor .

^‡ İstisnalar dışında. Üyelere işaretçileri desteklerken, result_ofgeçersiz bir tür kimliği başlatmaya çalışırsanız çalışmayacaktır . Bunlar, bir işlevi döndüren veya değere göre soyut türleri alan bir işlevi içerir. Ör .:

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

int answer() { return 42; }

call(answer); // nope

Doğru kullanım olurdu result_of_t<F&()>, ama bu hatırlamanız gerekmeyen bir ayrıntı decltype.