Functor'ın dönüş değeri nasıl hesaplanır?

Question

2 değeri ve bir functor veya bir lambda kabul eden bir şablon işlevi yazmak istiyorum. Fonksiyon, functor'ı bu değerlerle çağırır ve sonucu döndürür.

template <typename T, typename Fn> 
_ReturnTypeOfPred_ Apply(T x, T y, Fn fn) 
    { 
    return fn(x, y); 
    } 

Soru: Apply dönüş türünü tanımlamak nasıl Fn dönüş türü eşit olmak? Bu 1 örnek basitleştirilmiş edildi

funktor

template <typename T> 
auto Sum(T x, T y) -> decltype(x+y) 
    { 
    return x+y; 
    } 

Güncelleme bu örnekte olduğu gibi T için mutlaka eşit değildir. Bu bir işe yarıyor mu? Ben dönüş türü decltype yılında return ifadesini tekrarlamak durumunda

template <typename TContainer, typename Fn> auto Apply(const TContainer& x, const TContainer& y, Fn fn) -> decltype(fn(x.front(), y.front())) { return fn(x.front(), y.front()); } 

hep işe yarar mı? Daha zarif bir yolu var mı?

Answer 1

Neredeyse bitti; Sadece decltype kullanın:

template <typename T, typename Fn> 
auto Apply(T x, T y, Fn fn) -> decltype(fn(x, y)) 
{ 
    return fn(x, y); 
} 

Sen std::result_of (Difference between std::result_of and decltype) ama neden rahatsız kullanabilir? Takip soruya gelince

template <typename T, typename Fn> 
typename std::result_of<Fn, T, T>::type Apply(T x, T y, Fn fn) 
{ 
    return fn(x, y); 
} 

---

: hata eğilimli olabilir ama, decltype(<expression>) olacak genellikle çalışma ile return-type yerine bir fonksiyonu

auto fn(<args>) -> <return-type> { return <expression>; } 

için. Örneğin, göz önünde bulundurun:

İşte decltype

auto f(char c) -> decltype(std::string() += c) { return std::string() += c; } 

std::string & verecektir ve işlevi, bir yerel bir lvalue başvuru dönecektir! örneğin olma nedeni iade olmayan bir değer elde olabilir Diğer durumlarda

auto f(char c) -> std::remove_reference<decltype(std::string() += c)>::type { 
    return std::string() += c; 
} 

, <expression>: Bu şekilde değiştirilmesi gerekir Bir lambda, vb. içeren kopçasız, vb.