Преимущества использования форварда

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

В принципе, учитывая выражение E(a, b, ... , c), мы хотим, чтобы выражение f(a, b, ... , c) было эквивалентным. В С++ 03 это невозможно. Есть много попыток, но в любом случае все они терпят неудачу.

---

Простейшим является использование ссылки lvalue:

template <typename A, typename B, typename C>
void f(A& a, B& b, C& c)
{
    E(a, b, c);
}

Но это не позволяет обрабатывать временные значения: f(1, 2, 3);, поскольку они не могут быть привязаны к lvalue-reference.

Следующая попытка может быть следующей:

template <typename A, typename B, typename C>
void f(const A& a, const B& b, const C& c)
{
    E(a, b, c);
}

Что исправляет вышеуказанную проблему, но flips flops. Теперь он не позволяет E иметь неконстантные аргументы:

int i = 1, j = 2, k = 3;
void E(int&, int&, int&); f(i, j, k); // oops! E cannot modify these

Третья попытка принимает const-ссылки, но затем const_cast const прочь:

template <typename A, typename B, typename C>
void f(const A& a, const B& b, const C& c)
{
    E(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c));
}

Это принимает все значения, может передавать все значения, но потенциально приводит к поведению undefined:

const int i = 1, j = 2, k = 3;
E(int&, int&, int&); f(i, j, k); // ouch! E can modify a const object!

Окончательное решение обрабатывает все правильно... ценой невозможности поддерживать. Вы предоставляете перегрузки f со всеми комбинациями const и non-const:

template <typename A, typename B, typename C>
void f(A& a, B& b, C& c);

template <typename A, typename B, typename C>
void f(const A& a, B& b, C& c);

template <typename A, typename B, typename C>
void f(A& a, const B& b, C& c);

template <typename A, typename B, typename C>
void f(A& a, B& b, const C& c);

template <typename A, typename B, typename C>
void f(const A& a, const B& b, C& c);

template <typename A, typename B, typename C>
void f(const A& a, B& b, const C& c);

template <typename A, typename B, typename C>
void f(A& a, const B& b, const C& c);

template <typename A, typename B, typename C>
void f(const A& a, const B& b, const C& c);

N аргументов требуют 2 ^N комбинаций, кошмар. Мы хотели бы сделать это автоматически.

(Это фактически то, что мы получаем для компилятора для нас в С++ 11.)

---

В С++ 11 у нас есть шанс исправить это. Одно из решений изменяет правила вычитания шаблонов для существующих типов, но это потенциально может привести к большому количеству кода. Итак, нам нужно найти другой способ.

Решение состоит в том, чтобы вместо этого использовать вновь добавленные rvalue-ссылки; мы можем ввести новые правила при выводе типов rvalue-reference и создать любой желаемый результат. В конце концов, мы не можем сломать код сейчас.

Если задана ссылка на ссылку (ссылка на примечание - это охватывающий термин, означающий как T&, так и T&&), мы используем следующее правило для определения результирующего типа:

"[данный] тип TR, который является ссылкой на тип T, попытка создать тип" lvalue reference to cv TR "создает тип" lvalue reference to T ", в то время как попытка создать тип" Ссылка rvalue на cv TR "создает тип TR."

Или в табличной форме:

TR   R

T&   &  -> T&  // lvalue reference to cv TR -> lvalue reference to T
T&   && -> T&  // rvalue reference to cv TR -> TR (lvalue reference to T)
T&&  &  -> T&  // lvalue reference to cv TR -> lvalue reference to T
T&&  && -> T&& // rvalue reference to cv TR -> TR (rvalue reference to T)

Далее, с выводом аргумента шаблона: если аргумент является lvalue A, мы приводим аргумент шаблона с ссылкой lvalue на A. В противном случае мы выводим обычно. Это дает так называемые универсальные ссылки (термин ссылка для пересылки является официальной).

Почему это полезно? Поскольку в сочетании мы сохраняем способность отслеживать категорию значений типа: если это значение lvalue, у нас есть параметр lvalue-reference, в противном случае у нас есть параметр rvalue-reference.

В коде:

template <typename T>
void deduce(T&& x); 

int i;
deduce(i); // deduce<int&>(int& &&) -> deduce<int&>(int&)
deduce(1); // deduce<int>(int&&)

Последнее означает "переслать" категорию значений переменной. Имейте в виду, что когда-то внутри функции параметр может быть передан как значение l на что-либо:

void foo(int&);

template <typename T>
void deduce(T&& x)
{
    foo(x); // fine, foo can refer to x
}

deduce(1); // okay, foo operates on x which has a value of 1

Это нехорошо. E нужно получить ту же категорию ценностей, которую мы получили! Решение таково:

static_cast<T&&>(x);

Что это делает? Рассмотрим, что мы находимся внутри функции deduce, и нам передали lvalue. Это означает, что T является A&, поэтому целевой тип для статического литья A& && или просто A&. Поскольку x уже является A&, мы ничего не делаем и оставляем ссылку lvalue.

Когда нам передали rvalue, T - A, поэтому целевой тип для статического литья A&&. Листинг приводит к выражению rvalue, которое больше не может быть передано в ссылку lvalue. Мы сохранили категорию значений параметра.

Объединение этих данных дает нам "идеальную пересылку":

template <typename A>
void f(A&& a)
{
    E(static_cast<A&&>(a)); 
}

Когда f получает lvalue, E получает значение lvalue. Когда f получает rvalue, E получает значение r. Совершенная.

---

И, конечно, мы хотим избавиться от уродливых. static_cast<T&&> загадочно и странно запомнить; вместо этого сделайте служебную функцию с именем forward, которая делает то же самое:

std::forward<A>(a);
// is the same as
static_cast<A&&>(a);

Я думаю, что концептуальный код, реализующий std :: forward, может добавить к обсуждению. Это слайд со слова Скотта Мейерса "Эффективный С++ 11/14 Sampler"

Функция move в коде std::move. В этом разговоре есть (рабочая) реализация. Я нашел фактическую реализацию std :: forward в libstdc++, в файле move.h, но это совсем не поучительно.

С точки зрения пользователя, смысл этого заключается в том, что std::forward является условным приведением в r-значение. Это может быть полезно, если я пишу функцию, которая ожидает либо lvalue, либо rvalue в параметре и хочет передать ее другой функции как rvalue, только если она была передана как rvalue. Если бы я не переносил параметр в std :: forward, он всегда передавался как нормальная ссылка.

#include <iostream>
#include <string>
#include <utility>

void overloaded_function(std::string& param) {
  std::cout << "std::string& version" << std::endl;
}
void overloaded_function(std::string&& param) {
  std::cout << "std::string&& version" << std::endl;
}

template<typename T>
void pass_through(T&& param) {
  overloaded_function(std::forward<T>(param));
}

int main() {
  std::string pes;
  pass_through(pes);
  pass_through(std::move(pes));
}

Конечно, он печатает

std::string& version
std::string&& version

Код основан на примере из вышеупомянутого разговора. Слайд 10, примерно в 15:00 с самого начала.

В идеальной пересылке std:: forward используется для преобразования именованных rvalue-ссылок t1 и t2 в неназванный справочник rvalue. Для чего это нужно? Как это повлияет на вызванную функцию inner, если оставить t1 и t2 как lvalue?

template <typename T1, typename T2> void outer(T1&& t1, T2&& t2) 
{
    inner(std::forward<T1>(t1), std::forward<T2>(t2));
}

Если вы используете ссылочную ссылку rvalue в выражении, это фактически значение lvalue (потому что вы ссылаетесь на объект по имени). Рассмотрим следующий пример:

void inner(int &,  int &);  // #1
void inner(int &&, int &&); // #2

Теперь, если мы назовем outer следующим образом

outer(17,29);

мы хотели бы, чтобы 17 и 29 были перенаправлены на # 2, потому что 17 и 29 являются целыми литералами и как таковые значения r. Но так как t1 и t2 в выражении inner(t1,t2); являются lvalues, вы будете вызывать # 1 вместо # 2. Поэтому нам нужно вернуть ссылки в неназванные ссылки с помощью std::forward. Таким образом, t1 в outer всегда является выражением lvalue, а forward<T1>(t1) может быть выражением rvalue в зависимости от t1. Последний является только выражением lvalue, если t1 является ссылкой на lvalue. И t1 выводится только как ссылка lvalue в случае, если первый аргумент для внешнего является выражением lvalue.

Как это повлияет на вызываемую функцию inner, если оставить t1 и t2 как lvalue?

Если после экземпляра T1 имеет тип char, а T2 имеет класс, вы хотите передать T1 за копию и T2 за const ссылку. Ну, если inner() не принимает их за ссылку не const, то есть в этом случае вы тоже этого хотите.

Попробуйте написать набор функций outer(), которые реализуют это без ссылок rvalue, выведя правильный способ передать аргументы из типа inner(). Думаю, вам понадобится что-то 2 ^ 2 из них, довольно здоровенный шаблон-мета-материал, чтобы вывести аргументы, и много времени, чтобы получить это право для всех случаев.

И затем кто-то приходит с inner(), который принимает аргументы за указатель. Я думаю, что теперь он составляет 3 ^ 2. (Или 4 ^ 2. Черт, я не могу потрудиться, чтобы попытаться понять, имеет ли смысл указатель const.)

И тогда представьте, что вы хотите сделать это для пяти параметров. Или семь.

Теперь вы знаете, почему некоторые яркие мысли придумали "идеальную пересылку": это заставляет компилятор делать все это за вас.

Точка, которая не была прозрачной, - это то, что static_cast<T&&> правильно обрабатывает const T&.
Программа:

#include <iostream>

using namespace std;

void g(const int&)
{
    cout << "const int&\n";
}

void g(int&)
{
    cout << "int&\n";
}

void g(int&&)
{
    cout << "int&&\n";
}

template <typename T>
void f(T&& a)
{
    g(static_cast<T&&>(a));
}

int main()
{
    cout << "f(1)\n";
    f(1);
    int a = 2;
    cout << "f(a)\n";
    f(a);
    const int b = 3;
    cout << "f(const b)\n";
    f(b);
    cout << "f(a * b)\n";
    f(a * b);
}

Выдает:

f(1)
int&&
f(a)
int&
f(const b)
const int&
f(a * b)
int&&

Обратите внимание, что 'f' должно быть функцией шаблона. Если он определен как "void f (int & a), это не работает.

Возможно, стоит подчеркнуть, что forward необходимо использовать в тандеме с внешним методом с пересылкой/универсальной ссылкой. Использование пересылки само по себе, поскольку допускаются следующие утверждения, но не делает ничего хорошего, кроме как путаницы. Стандартный комитет может захотеть отключить такую ​​гибкость, иначе почему бы нам просто не использовать static_cast?

     std::forward<int>(1);
     std::forward<std::string>("Hello");

По моему мнению, перемещение и форвард - это шаблоны проектирования, которые являются естественными результатами после введения ссылочного типа r-value. Мы не должны называть метод, предполагающий его правильное использование, если неправильное использование запрещено.