爲什麼sfinae如果constexpr不允許？

Question

檢測成語的工作原理如下

template<typename T, typename = void> 
struct has_foo {static constexpr bool value = false;}; 
template<typename T> 
struct has_foo<T, std::void_t<decltype(&T::foo)>> {static constexpr bool value = true;}; 
template<typename T> 
constexpr bool has_foo_v = has_foo<T>::value; 

，然後我們可以檢測到任何類型的T的foo存在。

if constexpr(has_foo_v<decltype(var)>) 
    var.foo(); 

我的問題是，這是相當多輸入（讀：想砸我的鍵盤大量輸入），我想知道是否以下是可能的

if constexpr(std::void_t<decltype(&decltype(var)::foo)>(), true) 
    var.foo(); 

這是不。

背後有一個原因嗎？
更具體地說，如果這是允許的話，必須做出什麼樣的折衷？

Answer 1

您在使用指針的成員函數是一個壞主意;如果foo被重載，它虛假地失敗（你有一個foo，但不只是一個）。誰真的想要「你有一個富有」？幾乎沒有人。

這裏是一個簡短的版本：

template<class T> 
using dot_foo_r = decltype(std::declval<T>().foo()); 

template<class T> 
using can_foo = can_apply<dot_foo_r, T>; 

其中

namespace details { 
    template<template<class...>class, class, class...> 
    struct can_apply:std::false_type{}; 
    template<template<class...>class Z, class...Ts> 
    struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...>:std::true_type{}; 
} 
template<template<class...>class Z, class...Ts> 
using can_apply = details::can_apply<Z, void, Ts...>; 

現在，寫dot_foo_r是有點討厭。

隨着constexpr lambda我們可以使它更少討厭，並做到內聯。

#define RETURNS(...) \ 
    noexcept(noexcept(__VA_ARGS__)) \ 
    -> decltype(__VA_ARGS__) \ 
    { return __VA_ARGS__; } 

它確實需要RETURNS宏，至少要等到@巴里的提交[](auto&&f)RETURNS(f())相當於[](auto&&f)=>f()。

然後，我們寫can_invoke_f，這是一個constexpr變種std::is_invokable：

template<class F> 
constexpr auto can_invoke(F&& f) { 
    return [](auto&&...args)->std::is_invokable<F(decltype(args)...)>{ 
    return {}; 
    }; 
} 

這給我們：

if constexpr(
    can_invoke([](auto&&var) RETURNS(var.foo()))(var) 
) { 
    var.foo(); 
} 

或使用@巴里提出的C++ 20語法：

if constexpr(can_invoke(var=>var.foo())(var)) { 
    var.foo(); 
} 

我們完成了。

訣竅是，RETURNS宏（或=> C++ 20功能）讓我們對錶達式執行SFINAE。拉姆達變成了一種簡單的方式來表達這個表達式作爲一個值。

你可以寫

[](auto&&var) ->decltype(var.foo()) { return var.foo(); } 

，但我認爲RETURNS是值得的（我不喜歡宏）。

Answer 2

由於C++ 17總是有constexpr拉姆達的解決方法，如果你真的需要做SFINAE在線：

#include <utility> 

template <class Lambda, class... Ts> 
constexpr auto test_sfinae(Lambda lambda, Ts&&...) 
    -> decltype(lambda(std::declval<Ts>()...), bool{}) { return true; } 
constexpr bool test_sfinae(...) { return false; } 

template <class T> 
constexpr bool bar(T var) { 
    if constexpr(test_sfinae([](auto v) -> decltype(v.foo()){}, var)) 
     return true; 
    return false; 
} 

struct A { 
    void foo() {} 
}; 

struct B { }; 

int main() { 
    static_assert(bar(A{})); 
    static_assert(!bar(B{})); 
} 

[live demo]

Answer 3

您還可以使用std::is_detected來減少代碼量。

在你的榜樣，代碼則看起來像：

template <class T> 
using has_foo_t = decltype(std::declval<T>().foo()); 

if constexpr(std::is_detected_v<has_foo_t,decltype(var)>) 
    var.foo();