Блог

У меня есть функция, которая имеет параметр option типа T.

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

Все это было хорошо, но теперь у меня есть сценарий, в котором T становится void . В этом случае я ожидал, что пустая функция не будет работать. Единственное работоспособное решение, которое у меня есть, требует трех отдельных объявлений, и у меня есть много таких методов:

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

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

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

В идеале я надеюсь, что должно быть более элегантное решение для перегрузки функции ‘Void’, не прибегая к 3-му объявлению? Особенно с новым C 17, решающим так много задач в наши дни! Более краткий синтаксис, который был бы короче, мог бы быть приятным…

Более простое решение (в том смысле, что существует только 2 перегрузки) было бы примерно таким:

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

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

// void foo(const Tamp;); 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 Tamp; 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 Tamp; t = T()) {
    t.stuff;
}

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

Это сделают два параметра шаблона по умолчанию:

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

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

Пример.

intamp; значение по умолчанию для T so, чтобы компиляция завершилась неудачно (по умолчанию создается ссылка на U() ), если кто-то попытается вызвать foo() без аргумента шаблона или фактического аргумента (попробуйте раскомментировать его в примере).

Я использую int внутри FallbackT шаблона псевдонима, поскольку U просто должно быть что-то, что можно сконструировать по умолчанию — это не видно пользователю.

Если вы хотите быть фантазийным (и предотвратить неправильное использование), вы можете добавить защиту от переменных и использовать типы замыканий:

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

Здесь защита переменных предотвращает явное указание U, как, например foo<int, long>() ; типы замыкания делают невозможным вызов foo с этими типами любыми другими способами — это, вероятно, не нужно.

В идеале я надеюсь, что должно быть более элегантное решение для перегрузки функции ‘Void’, не прибегая к 3-му объявлению? Особенно с новым C 17, решающим так много задач в наши дни! Более краткий синтаксис, который был бы короче, мог бы быть приятным…

Хорошо… без 3-го объявления, да (вы можете использовать только один).

Более элегантный… я полагаю, это вопрос вкуса.

Более совпадающий синтаксис … хорошо… я полагаю, почти то же самое.

В любом случае, я предлагаю следующую версию 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 amp; u = U{})
 {
   if constexpr ( std::is_same_v<T, void> )
    { /* do nothing */ }
   else
    { /* do u.stuff; */ }
 }