Как сделать ссылочный параметр шаблона rvalue ТОЛЬКО привязываться к ссылке rvalue?

Ответ 1

Вы можете ограничить T не ссылкой на lvalue и, таким образом, не связывать lvalues ​​с ним:

#include <type_traits>

struct OwnershipReceiver
{
  template <typename T,
            class = typename std::enable_if
            <
                !std::is_lvalue_reference<T>::value
            >::type
           >
  void receive_ownership(T&& t)
  {
     // taking file descriptor of t, and clear t
  }
};

Также может быть хорошей идеей добавить какое-то ограничение на T, чтобы оно принимало только обертки дескриптора файла.

Ответ 2

Я благодарю Говарда за своевременный и полезный ответ, моя проблема решена.

И во время курса я узнаю что-то, что люди, кажется, запутались довольно часто: использование SFINAE в порядке, но я не могу использовать

std::is_rvalue_reference<T>::value

единственный способ, которым он работает, как я хочу, -

!std::is_lvalue_reference<T>::value

Причина такова: мне нужна моя функция для получения "rvalue", а не "ссылки на rvalue". Функция SFINAE ed с std:: is_rvalue_reference:: value не получит "rvalue", но получает только "ссылку на rvalue". (выйти из причуды, да?)

Ответ 3

Простым способом является предоставление удаленного элемента, который принимает ссылку lvalue:

template<typename T> void receive_ownership(T&) = delete;

Это всегда будет лучшим совпадением для аргумента lvalue.

Если у вас есть функция, которая принимает несколько аргументов, все из которых должны быть rvalues, нам понадобятся несколько удаленных функций. В этой ситуации мы можем предпочесть использовать SFINAE, чтобы скрыть функцию от любых аргументов lvalue.

Один из способов сделать это может быть с С++ 17 и концепциями TS:

#include <type_traits>

template<typename T>
void receive_ownership(T&& t)
    requires !std::is_lvalue_reference<T>::value
{
     // taking file descriptor of t, and clear t
}

или

#include <type_traits>

void receive_ownership(auto&& t)
    requires std::is_rvalue_reference<decltype(t)>::value
{
     // taking file descriptor of t, and clear t
}

Идя немного дальше, вы можете определить новую собственную концепцию, которая может быть полезна, если вы хотите ее повторно использовать, или просто для дополнительной ясности:

#include <type_traits>

template<typename T>
concept bool rvalue = std::is_rvalue_reference<T&&>::value;


void receive_ownership(rvalue&& t)
{
     // taking file descriptor of t, and clear t
}

Примечание: с GCC 6.1 вам нужно передать -fconcepts в компилятор, поскольку он является расширением для С++, а не его основной частью.

Просто для полноты, здесь мой простой тест:

#include <utility>
int main()
{
    int a = 0;
    receive_ownership(a);       // error
    receive_ownership(std::move(a)); // okay

    const int b = 0;
    receive_ownership(b);       // error
    receive_ownership(std::move(b)); // allowed - but unwise
}

Ответ 4

Для ссылок lvalue T выводится как ссылка lvalue, а для rvalue-ссылок T выводится как неосновная.

Итак, если функция связывается с ссылкой на rvalue, то, что видно в конце компилятором для определенного типа T, является:

std::is_rvalue_reference<T>::value

а не

std::is_rvalue_reference<T&&>::value

Ответ 5

К сожалению, кажется, что попробовать is_rvalue_reference<TF> (где TF - отлично переадресованный тип) не работает, если вы на самом деле пытаетесь сделать перегрузки, которые различают const T& и T&& (например, используя enable_if в обоих, один с is_rvalue_reference_v<TF>, а другой с !is_rvalue_reference_V<TF>).

Решение (пусть и взломанное) - это распад переадресованного T, а затем помещают перегрузки в контейнере, осведомленные об этих типах. Сгенерировано этот пример:

Hup, я был неправ, просто забыл посмотреть на ответ Тоби (is_rvalue_reference<TF&&>) - хотя это путает, что вы можете сделать std::forward<TF>(...), но я думаю, что поэтому работает decltype(arg).

Anywho, вот что я использовал для отладки: (1) используя перегрузки struct, (2) используя неправильную проверку для is_rvalue_reference и (3) правильную проверку:

/*
Output:

const T& (struct)
const T& (sfinae)
const T& (sfinae bad)
---
const T& (struct)
const T& (sfinae)
const T& (sfinae bad)
---
T&& (struct)
T&& (sfinae)
const T& (sfinae bad)
---
T&& (struct)
T&& (sfinae)
const T& (sfinae bad)
---
*/

#include <iostream>
#include <type_traits>

using namespace std;

struct Value {};

template <typename T>
struct greedy_struct {
  static void run(const T&) {
    cout << "const T& (struct)" << endl;
  }
  static void run(T&&) {
    cout << "T&& (struct)" << endl;
  }
};

// Per Toby answer.
template <typename T>
void greedy_sfinae(const T&) {
  cout << "const T& (sfinae)" << endl;
}

template <
    typename T,
    typename = std::enable_if_t<std::is_rvalue_reference<T&&>::value>>
void greedy_sfinae(T&&) {
  cout << "T&& (sfinae)" << endl;
}

// Bad.
template <typename T>
void greedy_sfinae_bad(const T&) {
  cout << "const T& (sfinae bad)" << endl;
}

template <
    typename T,
    typename = std::enable_if_t<std::is_rvalue_reference<T>::value>>
void greedy_sfinae_bad(T&&) {
  cout << "T&& (sfinae bad)" << endl;
}

template <typename TF>
void greedy(TF&& value) {
  using T = std::decay_t<TF>;
  greedy_struct<T>::run(std::forward<TF>(value));
  greedy_sfinae(std::forward<TF>(value));
  greedy_sfinae_bad(std::forward<TF>(value));
  cout << "---" << endl;
}

int main() {
  Value x;
  const Value y;

  greedy(x);
  greedy(y);
  greedy(Value{});
  greedy(std::move(x));

  return 0;
}