Différence C ++ entre std :: ref (T) et T &?

J'ai quelques questions concernant ce programme:

#include <iostream>
#include <type_traits>
#include <functional>
using namespace std;
template <typename T> void foo ( T x )
{
    auto r=ref(x);
    cout<<boolalpha;
    cout<<is_same<T&,decltype(r)>::value;
}
int main()
{
    int x=5;
    foo (x);
    return 0;
}

La sortie est:

false

Je veux savoir, si std::refne renvoie pas la référence d'un objet, alors que fait-il? En gros, quelle est la différence entre:

T x;
auto r = ref(x);

et

T x;
T &y = x;

Aussi, je veux savoir pourquoi cette différence existe? Pourquoi avons-nous besoin std::refou std::reference_wrapperquand nous avons des références (ie T&)?

Well refconstruit un objet du reference_wrappertype approprié pour contenir une référence à un objet. Ce qui signifie que lorsque vous postulez:

auto r = ref(x);

Cela renvoie a reference_wrapperet non une référence directe à x(ie T&). Ceci reference_wrapper(c'est-à-dire r) tient plutôt T&.

A reference_wrapperest très utile lorsque vous voulez émuler un referenceobjet qui peut être copié (il est à la fois constructible et assignable par copie ).

En C ++, une fois que vous créez une référence ( par exemple y) à un objet ( par exemple x), puis yet xpartager la même adresse de base . De plus, yne peut faire référence à aucun autre objet. De plus, vous ne pouvez pas créer un tableau de références, c'est-à-dire qu'un code comme celui-ci générera une erreur:

#include <iostream>
using namespace std;

int main()
{
    int x=5, y=7, z=8;
    int& arr[] {x,y,z};    // error: declaration of 'arr' as array of references
    return 0;
}

Cependant, c'est légal:

#include <iostream>
#include <functional>  // for reference_wrapper
using namespace std;

int main()
{
    int x=5, y=7, z=8;
    reference_wrapper<int> arr[] {x,y,z};
    for (auto a: arr)
        cout << a << " ";
    return 0;
}
/* OUTPUT:
5 7 8
*/

En parlant de votre problème avec cout << is_same<T&,decltype(r)>::value;, la solution est:

cout << is_same<T&,decltype(r.get())>::value;  // will yield true

Laissez-moi vous montrer un programme:

#include <iostream>
#include <type_traits>
#include <functional>
using namespace std;

int main()
{
    cout << boolalpha;
    int x=5, y=7;
    reference_wrapper<int> r=x;   // or auto r = ref(x);
    cout << is_same<int&, decltype(r.get())>::value << "\n";
    cout << (&x==&r.get()) << "\n";
    r=y;
    cout << (&y==&r.get()) << "\n";
    r.get()=70;
    cout << y;
    return 0;
}
/* Ouput:
true
true
true
70
*/

Voyez ici, nous apprenons à connaître trois choses:

1. Un reference_wrapperobjet (ici r) peut être utilisé pour créer un tableau de références qui n'était pas possible avec T&.

2. ragit en fait comme une véritable référence (voir comment a r.get()=70changé la valeur de y).

3. rn'est pas le même que T&mais r.get()est. Cela signifie que rtient T&ie comme son nom l'indique est un wrapper autour d'une référence T& .

J'espère que cette réponse est plus que suffisante pour expliquer vos doutes.

std::reference_wrapper est reconnu par les installations standard pour pouvoir transmettre des objets par référence dans des contextes de passage par valeur.

Par exemple, std::bindpeut prendre le std::ref()vers quelque chose, le transmettre par valeur et le décompresser dans une référence plus tard.

void print(int i) {
    std::cout << i << '\n';
}

int main() {
    int i = 10;

    auto f1 = std::bind(print, i);
    auto f2 = std::bind(print, std::ref(i));

    i = 20;

    f1();
    f2();
}

Cet extrait de code affiche:

10
20

La valeur de ia été stockée (prise par valeur) f1au point où elle a été initialisée, mais f2a conservé une std::reference_wrappervaleur par, et se comporte donc comme si elle avait pris un int&.

Une référence ( T&ou T&&) est un élément spécial du langage C ++. Il permet de manipuler un objet par référence et a des cas d'utilisation particuliers dans le langage. Par exemple, vous ne pouvez pas créer un conteneur standard pour contenir des références: vector<T&>est mal formé et génère une erreur de compilation.

A std::reference_wrapperd'autre part est un objet C ++ capable de contenir une référence. En tant que tel, vous pouvez l'utiliser dans des conteneurs standard.

std::refest une fonction standard qui renvoie un std::reference_wrappersur son argument. Dans la même idée, std::crefretourne std::reference_wrapperà une référence const.

Une propriété intéressante de a std::reference_wrapper, est qu'il a un operator T& () const noexcept;. Cela signifie que même s'il s'agit d'un véritable objet , il peut être automatiquement converti en référence qu'il contient. Donc:

• comme il s'agit d'un objet assignable par copie, il peut être utilisé dans des conteneurs ou dans d'autres cas où les références ne sont pas autorisées
• grâce à son operator T& () const noexcept;, il peut être utilisé partout où vous pouvez utiliser une référence, car il y sera automatiquement converti.