Иметь ссылку на rvalue вместо ссылки на пересылку с вариативным шаблоном

Можно получить кучу ссылок на rvalue с помощью SFINAE:

template <class... Args,
    std::enable_if_t<(!std::is_lvalue_reference<Args>::value && ...), int> = 0>
void foo(Args&&... args) { ... }

Fold-выражения — это С++ 17, достаточно просто написать метафункцию, чтобы получить такое же поведение в С++ 14. На самом деле это ваш единственный вариант - вы хотите, чтобы шаблон ограниченной функции выводил ссылки на rvalue, но единственный доступный синтаксис перегружен, чтобы означать переадресацию ссылок. Мы могли бы сделать параметры шаблона невыводимыми, но тогда вам пришлось бы их предоставлять, что кажется совсем не решением.

С концепциями это, конечно, чище, но мы на самом деле не меняем основной механизм:

template <class... Args>
    requires (!std::is_lvalue_reference<Args>::value && ...)
void foo(Args&&... args) { ... }

или лучше:

template <class T>
concept NonReference = !std::is_lvalue_reference<T>::value;

template <NonReference... Args>
void foo(Args&&... ) { ... }

Стоит отметить, что ни один из них не работает:

template <class... Args> auto foo(const Args&... args) = delete;
template <class... Args> auto foo(Args&... args) = delete;

потому что они удаляют только те перегрузки, которые принимают все ссылки lvalue, а вы хотите удалить перегрузки, которые принимают любые ссылки lvalue.

Я знаю, как решить эту проблему с помощью static_assert или SFINAE, но оба эти решения немного усложняют [...] есть ли простое решение/трюк, который мне не хватает [...]?

Существует довольно хороший способ сделать это без сложных выражений SFINAE или static_assert. Это также не требовало от вас угадывать, какие параметры были константными, а какие нет (это могло быстро привести вас к UB, если вы все-таки попытаетесь поиграть с константностью переменных). Кроме того, вам не нужно включать <type_traits> для этого, если вам это небезразлично.
Он основан на @Justin answer почти так и было.

Давайте посмотрим код. Просто используйте decltype и тестовую функцию, для которой вам требуется только объявление, без определения вообще:

#include<utility>

template<typename... T>
void test(const T &&...);

template <class... Args>
auto foo(Args&&... args)
-> decltype(test(std::forward<Args>(args)...), void())
{}

struct X {};

int main() {
    X x1, x2;
    //foo(x1, x2);
    foo(std::move(x1), std::move(x2));
    foo(X{}, X{});
}

Если вы переключите комментарий, пример больше не будет компилироваться в соответствии с запросом.

Основная идея почти такая же, как обсуждалось в другом ответе: если это ссылка на rvalue, вы можете назначить ее ссылке const rvalue. В любом случае, поскольку вы не хотите делать константными те параметры, которые изначально не были константными, просто протестируйте их все вместе, а затем используйте исходные.

Если вы действительно хотите избежать SFINAE, вы можете принять свои аргументы const&&; они не будут универсальными ссылками:

template <class... Args>
auto foo(const Args&&... args) -> void { ... };

const&& может быть привязан только к rvalue, но не к lvalue.

#include <iostream>

template <class... Args>
auto foo(const Args&&... args) -> void
{
    std::cout << __PRETTY_FUNCTION__ << '\n';
}

struct X {};

int main () {
    X x1, x2;
    // foo(x1, x2);                    // compile error
    foo(std::move(x1), std::move(x2)); // accepted [OK]
    // foo(std::move(x1), x2);         // compile error
    foo(X{}, X{});                     // accepted [OK]
}

На Coliru

К сожалению, тогда вам придется отбросить const, так что это не самое красивое решение.