C ++ Різниця між std :: ref (T) та T &?

Question 1

У мене є кілька питань щодо цієї програми:

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

Результат:

false

Я хочу знати, якщо std::refне повертає посилання на об'єкт, то що він робить? В основному, в чому різниця між:

T x;
auto r = ref(x);

і

T x;
T &y = x;

Крім того, я хочу знати, чому існує ця різниця? Навіщо нам це потрібно std::refабо std::reference_wrapperколи у нас є посилання (тобто T&)?

Question 2

Ну refконструює об'єкт відповідного reference_wrapperтипу для зберігання посилання на об'єкт. Що означає, коли ви подаєте заявку:

auto r = ref(x);

Це повертає a, reference_wrapperа не пряме посилання на x(тобто T&). Це reference_wrapper(тобто r) натомість справедливо T&.

A reference_wrapperдуже корисний, коли ви хочете емулювати a referenceоб'єкта, який можна скопіювати (він одночасно може бути створений для копіювання та призначений для копіювання) ).

У C ++, як тільки ви створюєте посилання (скажімо y) на об'єкт (скажімо x), тоді yі xнадаєте ту саму базову адресу . Крім того, yне може посилатися на будь-який інший об'єкт. Крім того, ви не можете створити масив посилань, тобто такий код викличе помилку:

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

Однак це законно:

#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
*/

Говорячи про вашу проблему cout << is_same<T&,decltype(r)>::value;, рішення:

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

Дозвольте показати програму:

#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
*/

Дивіться тут, ми дізнаємось про три речі:

reference_wrapperОб'єкт (тут r) можна використовувати для створення масиву посилань , які не вдалися з T&.
rнасправді діє як справжнє посилання (подивіться, як r.get()=70змінилося значення y).
rне те саме, що є, T&але r.get()є. Це означає, що rмає місце, T&тобто, як випливає з назви, є обгорткою навколо посилання T& .

Сподіваюся, цієї відповіді більш ніж достатньо, щоб пояснити ваші сумніви.

Question 3

std::reference_wrapper визнається стандартними засобами для передачі об'єктів за посиланням у контексті передачі значення.

Наприклад, std::bindможна взяти std::ref()щось, передати його за значенням і розпакувати назад у посилання пізніше.

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

Цей фрагмент виводить:

10
20

Значення iбуло збережено (взято за значенням) у f1момент, коли воно було ініціалізоване, але f2збережене std::reference_wrapperзначення за значенням, і, отже, поводиться так, як прийнято в int&.

Question 4

Посилання ( T&або T&&) - це спеціальний елемент мови С ++. Це дозволяє маніпулювати об’єктом за допомогою посилання та має особливі випадки використання в мові. Наприклад, ви не можете створити стандартний контейнер для зберігання посилань: vector<T&>неправильно сформований та генерує помилку компіляції.

A, std::reference_wrapperз іншого боку, - це об'єкт C ++, здатний утримувати посилання. Таким чином, ви можете використовувати його у звичайних контейнерах.

std::refє стандартною функцією, яка повертає a std::reference_wrapperдля свого аргументу. У тій же ідеї std::crefповертається std::reference_wrapperдо посилання const.

Однією з цікавих властивостей a std::reference_wrapperє те, що він має an operator T& () const noexcept;. Це означає, що навіть якщо це справжній об'єкт , його можна автоматично перетворити на посилання, яке він містить. Тому:

оскільки це об’єкт, який можна призначити для копіювання, його можна використовувати в контейнерах або в інших випадках, коли посилання заборонені
завдяки цьому його operator T& () const noexcept;можна використовувати де завгодно, де б ви могли використовувати посилання, оскільки воно буде автоматично перетворено в нього.