Avantages de l'utilisation de l'avant

De transfert parfait, std::forward est utilisé pour convertir le nommé références rvalue t1 et t2 anonymes références rvalue. Quel est le but de le faire? Comment cela affecterait-il la fonction appelée inner si nous laissons t1 & t2 comme lvalues?

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

InformationsquelleAutor Steveng | 2010-08-27

c++c++-faq c++11 perfect-forwarding rvalue-reference

730

Vous devez comprendre la transmission de problème. Vous pouvez lire l'intégralité du problème en détail, mais je vais résumer.

Fondamentalement, compte tenu de l'expression E(a, b, ... , c), nous voulons l'expression f(a, b, ... , c) équivalent. En C++03, c'est impossible. Il y a beaucoup de tentatives, mais ils ont tous échoué dans certains égard.

Le plus simple est d'utiliser une lvalue-référence:
```
template <typename A, typename B, typename C>
void f(A& a, B& b, C& c)
{
    E(a, b, c);
}
```
Mais cela ne parvient pas à gérer des valeurs temporaires: f(1, 2, 3);, que ceux qui ne peuvent pas être lié à une lvalue de référence.

La prochaine tentative peut-être:
```
template <typename A, typename B, typename C>
void f(const A& a, const B& b, const C& c)
{
    E(a, b, c);
}
```
Qui résout le problème ci-dessus, mais flips flops. Désormais, elle ne parvient pas à permettre E non-const arguments:
```
int i = 1, j = 2, k = 3;
void E(int&, int&, int&); f(i, j, k); //oops! E cannot modify these
```
La troisième tentative accepte const-références, mais alors const_cast's la const loin:
```
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));
}
```
Ce accepte toutes les valeurs, peut passer sur toutes les valeurs, mais aussi, potentiellement, conduit à un comportement indéfini:
```
const int i = 1, j = 2, k = 3;
E(int&, int&, int&); f(i, j, k); //ouch! E can modify a const object!
```
Une solution finale s'occupe de tout correctement...au prix d'être impossible à maintenir. Vous fournir des surcharges de f, avec tous combinaisons de const et 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 arguments besoin de 2^N combinaisons, un cauchemar. Nous aimerions faire cela automatiquement.

(C'est effectivement ce que nous obtenons le compilateur de faire pour nous en C++11.)

En C++11, on a une chance de résoudre ce problème. Une solution modifie modèle de règles de déduction sur les types existants, mais cela risque de casse une grande quantité de code. Nous devons donc trouver un autre moyen.

La solution est d'utiliser à la place de la nouvelle rvalue-références; nous pouvons introduire de nouvelles règles lorsque le retrait rvalue-types de référence et la création de résultat souhaité. Après tout, nous ne pouvons pas le code de saut de maintenant.

Si une référence à une référence (note de référence est un terme général signifiant à la fois T& et T&&), nous utilisons la règle suivante pour déterminer le type résultant:

"[donné] un type TR qui est une référence à un type T, une tentative de créer le type “lvalue de référence pour cv TR” crée le type “lvalue référence à T”, alors qu'une tentative de créer le type “référence rvalue de cv TR” crée le type TR."

Ou sous forme de tableaux:
```
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)
```
Prochaine, avec l'argument de modèle déduction: si un argument est une lvalue, nous offre l'argument de modèle avec une lvalue référence à A. dans le cas Contraire, nous en déduisons que normalement. Cela donne soi-disant des références universelles (le terme la redirection de référence est maintenant officiel).

Pourquoi est-ce utile? Parce combiné nous maintenir la capacité de garder la trace de la valeur de la catégorie de type: si c'était une lvalue, nous avons une lvalue paramètre de référence, sinon nous avons une rvalue paramètre de référence.

Dans le code:
```
template <typename T>
void deduce(T&& x); 

int i;
deduce(i); //deduce<int&>(int& &&) -> deduce<int&>(int&)
deduce(1); //deduce<int>(int&&)
```
La dernière chose est de "suivre" la valeur de la catégorie de la variable. Gardez à l'esprit, une fois à l'intérieur de la fonction, le paramètre peut être passé comme une lvalue à rien:
```
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
```
Ce n'est pas bon. E besoin pour obtenir le même type de valeur de la catégorie que nous avons eu! La solution est: est-ce
```
static_cast<T&&>(x);
```
À quoi ça sert? Considérons que nous sommes à l'intérieur du deduce fonction, et nous avons passé une lvalue. Cela signifie T est un A&, et donc le type de cible pour la statique de la fonte est A& &&, ou tout simplement A&. Depuis x est déjà un A&, nous ne faisons rien et sont à gauche avec une lvalue de référence.

Quand nous avons passé une rvalue, T est A, de sorte que le type de cible pour la statique de la fonte est A&&. La distribution des résultats dans une rvalue expression, qui ne peut plus être transmis à une lvalue de référence. Nous avons maintenu la valeur du paramètre.

Mettre ces ensemble nous donne la "perfect forwarding":
```
template <typename A>
void f(A&& a)
{
    E(static_cast<A&&>(a)); 
}
```
Quand f reçoit une lvalue, E obtient une lvalue. Lorsque f reçoit une rvalue, E obtient une rvalue. Parfait.

Et bien sûr, nous voulons nous débarrasser de ce qui est laid. static_cast<T&&> est énigmatique et étrange de se rappeler; nous allons plutôt faire une fonction utilitaire appelé forward, qui fait la même chose:
```
std::forward<A>(a);
//is the same as
static_cast<A&&>(a);
```
- Ne serait pas f une fonction, et non pas une expression?
- Haha. 🙂 <3 @mfukar: C'est un appel de fonction de l'expression. f lui-même pourrait être n'importe quoi "callable"; une fonction de pointeur de fonction, ou de la fonction de l'objet.
- Merci pour votre réponse détaillée. Juste une question, en déduire(1), x est de type int&& ou int? Parce que je pense que j'ai lu quelque part que si c'est rvalue type, la T pourrait être résolu à l'int. Donc, avec la extra &&, il serait int&& type de. Quelqu'un pourrait-il préciser que? thbecker.net/articles/rvalue_references/section_08.html
- Votre dernière tentative n'est pas correct à l'égard de l'énoncé du problème: Il va de l'avant const valeurs comme la non-const, donc pas de transfert à tous. Notez également que dans la première tentative, le const int i seront acceptées: A est déduit à const int. Les échecs sont pour les rvalues littéraux. Notez également que, pour l'appel à deduced(1), x est int&&, pas int (transfert parfait jamais fait une copie, comme le ferait si x serait d'une valeur de paramètre). Simplement T est int. La raison que x évalue à une lvalue dans le transitaire est parce que nommé références rvalue devenir lvalue expressions.
- En utilisant le C++0x expression taxonomie: x évalue à un lvalue dans le transitaire et static_cast<T&&>(x) évalue à un value dans le transitaire. Lvalues et xvalues sont appelés les glvalues. Prvalues (littéraux, etc...) et xvalues sont appelés les rvalues.
- Désolé pour la lenteur de la réponse. @Steveng: Oui, j'ai été incorrect, comme Johannes expliqué. @Johannes: Merci pour les corrections (et bah pour ma part, pour A être déduites à const int dans la première partie, n'était tout simplement pas à l'esprit.) Je vais vous avouer que je n'ai pas encore lu la nouvelle taxonomie ou de règles de déduction. :S (fait Juste, pas trop mal.) Est-ce correct?
- je l'aime maintenant =)
- Ouf. 🙂
- Cette réponse est positive en circulation. Si je pouvais jusqu'-voter plusieurs fois, et j'ai grâce à @Johannes pour les corrections. Cette honnêtement appartient comme un wiki candidat.
- Merci!
- Quelle est la différence dans l'utilisation de forward ou move ici? Ou est-ce juste une différence sémantique?
- doit être appelée sans modèle explicite les arguments et aboutit toujours à une rvalue, tandis que std::forward peuvent alors soit. Utilisation std::move quand vous savez que vous n'avez plus besoin de la valeur et vous souhaitez le déplacer ailleurs, l'utilisation std::forward de le faire selon les valeurs transmises à votre modèle de fonction.
- Merci pour le démarrage avec des exemples concrets de la première et de motiver le problème; très utile!
- C'est une excellente réponse. Il me rend aussi heureux que Python utilise seulement les appeler par leur objet et triste que je dois utiliser C++.
- Belle Explication. Viens de tomber sur cet article qui donne une bonne explication thbecker.net/articles/rvalue_references/section_01.html
- pas besoin d'autres réponses, ce que Scott Meyers a présenté dans son livre et a été joliment et très présentées dans cette réponse. Superbe
- Où il dit: "Lorsque nous avons passé une rvalue, T est Un" - pourquoi est-ce? Pourquoi est T pas Un&&? Le principe de base énoncé std::forward() semble charnières sur cela, mais je ne comprends pas pourquoi le compilateur pourrait en déduire que T est Une, quand il peut facilement en déduire qu'il soit Un&& (ce qui évite la nécessité pour les std::forward()).
- Cela fait assez longtemps que je suis maintenant flou sur les détails, mais SI elle allait se briser existant (avant c++11) du code. Je ne peux pas évoquer un exemple évident, peut-être template <typename T> void check(const T&)?
InformationsquelleAutor GManNickG
51

Je pense avoir conceptuel de l'application du code des std::forward peut ajouter à la discussion. C'est une diapositive à partir de Scott Meyers parler Effective C++11/14 Sampler

Fonction move dans le code est std::move. Il y a un (de travail) mise en œuvre pour plus tôt dans ce discours. J'ai trouvé mise en œuvre effective de std::forward dans libstdc++, dans le fichier à déplacer.h, mais il n'est pas instructif.

À partir d'un point de vue utilisateur, la signification de cela est que std::forward est une condition de fonte pour une rvalue. Il peut être utile si je suis en train d'écrire une fonction qui attend une lvalue ou rvalue dans un paramètre et veut passer à une autre fonction comme une rvalue que s'il est transmis sous la forme d'une rvalue. Si je n'ai pas envelopper le paramètre dans std::forward, il serait toujours passé comme une normale de référence.
```
#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));
}
```
Assez sûr, il imprime
```
std::string& version
std::string&& version
```
Le code est basé sur un exemple déjà mentionné parler. Diapositive 10, à environ 15:00 depuis le début.
- Votre second lien a fini par pointer quelque part complètement différent.
InformationsquelleAutor user7610
26
De transfert parfait, std::forward est utilisé pour convertir le nommé référence rvalue t1 et t2 à sans nom, référence rvalue. Quel est le but de le faire? Comment serait-ce l'effet de la fonction appelée intérieure si nous laissons t1 & t2 comme lvalue?
```
template <typename T1, typename T2> void outer(T1&& t1, T2&& t2) 
{
    inner(std::forward<T1>(t1), std::forward<T2>(t2));
}
```
Si vous utilisez un nom de référence rvalue dans une expression, il est en fait une lvalue (parce que vous vous référez à l'objet par son nom). Considérons l'exemple suivant:
```
void inner(int &,  int &);  //#1
void inner(int &&, int &&); //#2
```
Maintenant, si nous appelons outer comme ce
```
outer(17,29);
```
nous aimerions 17 et 29 à être transmis à #2, car les 17 et 29 sont des entiers littéraux et en tant que tel rvalues. Mais depuis t1 et t2 dans l'expression inner(t1,t2); sont lvalues, vous seriez en invoquant #1 à la place de #2. C'est pourquoi nous avons besoin de tourner les références dans les références sans nom avec std::forward. Donc, t1 dans outer est toujours une lvalue expression tout en forward<T1>(t1) peut être une rvalue expression en fonction de T1. Ce dernier est seulement une lvalue expression si T1 est une lvalue de référence. Et T1 est uniquement déduite d'être une lvalue de référence dans le cas où le premier argument à l'extérieur est une lvalue expression.
- Enfin, une explication claire 🙂
- C'est une sorte de édulcorée explication, mais très bien fait et fonctionnel explication. Les gens devraient lire cette réponse en premier et ensuite aller plus loin, si désiré
InformationsquelleAutor sellibitze
11

Comment cela affecterait-il la fonction appelée intérieure si nous laissons t1 & t2 comme lvalue?

Si, après l'instanciation, T1 est de type char, et T2 est d'une classe, vous voulez passer t1 par copie et t2 par const de référence. Eh bien, à moins que inner() les prend par la non-const de référence, qui est, dans le cas où vous voulez le faire, trop.

Essayer d'écrire un ensemble de outer() fonctions qui implémentent cette sans références rvalue, en déduire la bonne façon de passer les arguments à partir de inner()'s type. Je pense que vous aurez besoin de quelque chose 2^2 d'entre eux, assez bien membré, un modèle de méta trucs pour en déduire les arguments, et beaucoup de temps pour obtenir ce droit pour tous les cas.

Et puis quelqu'un vient avec une inner() qui prend comme arguments par pointeur. Je pense que le fait maintenant 3^2. (Ou 4^2. L'enfer, je ne peux pas être pris la peine d'essayer de réfléchir si const pointeur de faire la différence.)

Et puis imaginez que vous voulez faire cela pour une durée de cinq paramètres. Ou sept.

Maintenant vous savez pourquoi certains esprits lumineux est venu avec "le transfert parfait": Il fait le compilateur de faire tout cela pour vous.

InformationsquelleAutor sbi

Un point qui n'a pas été clairs sur le fait que static_cast<T&&> poignées const T& correctement aussi.

Programme:

#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);
}

Produit:

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

Noter que 'f' est une fonction de modèle. Si c'est simplement défini comme " void f(int&& a)' cela ne fonctionne pas.

bon point, donc T&& en statique casting est aussi suit de référence de l'effondrement des règles, non?

InformationsquelleAutor lalawawa

2

Il peut être intéressant de souligner que l'avant doit être utilisé en tandem avec une méthode extérieure de l'envoi/de référence universel. À l'aide de l'avant par lui-même que les énoncés suivants est autorisé, mais n'est d'aucune utilité autre que de causer de la confusion. Comité de la norme souhaiterez peut-être désactiver cette flexibilité autrement, pourquoi ne pas simplement utiliser static_cast à la place?
```
     std::forward<int>(1);
     std::forward<std::string>("Hello");
```
À mon avis, de se déplacer et sont des modèles de conception qui sont naturelles des résultats après la r-valeur de référence de type est introduite. Nous ne devrions pas le nom d'une méthode en supposant qu'il est correctement utilisée, à moins que la mauvaise utilisation est interdite.
- Je ne pense pas que le C++ comité estime que le fardeau de la preuve est sur eux pour utiliser le langage des idiomes "correctement", ni même de définir ce que "correct" utilisation (mais ils peuvent certainement vous donner des lignes directrices). À cette fin, tandis que d'une personne, les enseignants, les patrons et les amis peuvent avoir un devoir de les orienter d'une manière ou d'une autre, je crois que le comité C++ (et donc de la norme) n'ont pas cette obligation.
- Ouais, je viens de lire N2951 et je suis d'accord que le comité n'a pas l'obligation d'ajouter inutilement des limites concernant l'utilisation d'une fonction. Mais les noms de ces deux modèles de fonction (déplacer et à terme), sont en effet un peu confus, ne voyant que leurs définitions dans le fichier de la bibliothèque ou de la norme de documentation (23.2.5 Avant/déplacer les aides). Les exemples dans la norme certainement aider à comprendre le concept, mais il pourrait être utile d'ajouter des remarques à faire des choses un peu plus claire.
InformationsquelleAutor colin

Vous devez vous connecter pour publier un commentaire.