当 T==void 时如何最好地解决“void foo(const T& t = T())”

Question

我有一个函数，它有一个 T 类型的选项参数。

template<typename T>  
void foo( const T& t = T() )  
{ t.stuff; }

这一切都很好，但我现在有一个 T 变成 void 的场景。在这种情况下，我期望一个无操作的空函数。我唯一可行的解​​决方案需要三个单独的声明，并且我有许多这样的方法：

template<typename T> 
void foo( const T& t)
{ t.stuff; }

template<typename T>
inline void foo() 
{ foo(T()); }

template<> 
inline void foo<void>() {}

理想情况下，我希望应该有一个更优雅的解决方案来重载“Void”函数而不诉诸第三个声明？尤其是现在新的 C++17 解决了很多事情！更简洁的语法更短可能会很好......

Answer 1

两个默认的模板参数可以做到这一点：

template<class T> using FallbackT = std::conditional_t<std::is_void_v<T>, int, T>;

template<class T = int&, class U = FallbackT<T>>
void foo(U const& t = U()) {
    if constexpr (!std::is_void_v<T>)
        t.stuff();
}

Example.

int& 是 T 的默认值，因此如果有人尝试在没有模板参数或实际参数的情况下调用 foo()（尝试在例子）。

我在 FallbackT 别名模板中使用 int，因为 U 只需要是默认可构造的 - 这对用户不可见。

如果你想花哨（并防止误用），你可以添加一个可变参数守卫并使用闭包类型：

template<
    class T = decltype([]{})&,
    class...,
    class U = std::conditional_t<std::is_void_v<T>, decltype([]{}), T>>
void foo(U const& t = U()) {
    if constexpr (!std::is_void_v<T>)
        t.stuff();
}

在这里，可变参数保护防止明确指定 U，例如foo<int, long>();闭包类型使某人无法通过任何其他方式使用这些类型调用 foo - 这可能是不必要的。

Answer 2

一个更简单的解决方案（因为只有 2 个重载）是这样的：

template<typename T>
void foo( const T& t = T() ) {
    t.stuff;
}

template<typename T>
std::enable_if_t<std::is_void_v<T>>
foo() {}

// void foo(const T&); is the only viable overload for non-void T,
// since std::enable_if_t SFINAEs

// void foo(); is the only viable overload for void T,
// since const T& forms a reference to void

由于您经常使用这种模式，因此可以使用别名模板稍微缩短：

template<typename T, typename TypeIfVoid = void>
using if_void = std::enable_if_t<std::is_void_v<T>, TypeIfVoid>;


template<typename T>
void foo(const T& t = T()) {
    t.stuff;
}

template<typename T>
if_void<T> foo() {}

Answer 3

理想情况下，我希望应该有一个更优雅的解决方案来重载“Void”函数而不诉诸第三个声明？尤其是现在新的 C++17 解决了很多事情！更简洁的语法更短可能会很好......

嗯...没有第三个声明，是的（你只能使用一个）。

更优雅……我想这是品味的问题。

更简洁的语法......嗯......几乎一样，我想。

无论如何，我建议使用以下版本，基于if constexpr 和std::conditional_t。

template <typename T,
          typename U = std::conditional_t<std::is_same_v<T, void>,
                                          int,
                                          T>>
void foo (U const & u = U{})
 {
   if constexpr ( std::is_same_v<T, void> )
    { /* do nothing */ }
   else
    { /* do u.stuff; */ }
 }