Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Referenca za prosljeđivanje `F&&`

Kada se `F` izvodi iz argumenta, `F&&` se može vezati uz lvalue ili rvalue. Poziv `f()` tretira pozivljivi objekt kao lvalue; `std::forward<F>(f)` prosljeđuje ga kao lvalue ili rvalue, ovisno o argumentu.

Verzija: ISO C++23; implementation support may vary

Sintaksa

#include <utility>

template<class F>
void call(F&& f) {
    std::forward<F>(f)();
}

U template<class F> void call(F&& f) parametar f jest referenca za prosljeđivanje: && se primjenjuje izravno na parametar tipa F, bez dodavanja const ili volatile, a F se izvodi pri pozivu. Za lvalue tipa T izvodi se F = T&, pa nakon sažimanja referenci f ima tip T&. Za rvalue tipa T izvodi se F = T, pa f ima tip T&&. Kvalifikatori tipa argumenta, poput const, ostaju sačuvani.

Sam zapis && nije dovoljan. const F&&, konkretni tip kao što je Callable&& i F&& kada je F već određen specijalizacijom predloška klase nisu reference za prosljeđivanje.

U pozivu f() izraz f jest lvalue čak i kada je deklarirani tip parametra Callable&&. std::forward<F>(f) iz <utility> koristi izvedeni F: za objekte daje lvalue ako je argument lvalue i xvalue (vrstu rvalue izraza) ako je argument rvalue. To može promijeniti izbor između preopterećenja operator()() & i operator()() &&.

std::forward sam po sebi ne kopira niti premješta objekt i ne produljuje mu životni vijek. Privremeni objekt vezan uz referentni parametar živi do kraja potpunog izraza koji sadrži poziv. Zadržana referenca na taj objekt nakon toga upućuje na objekt koji više ne postoji.

Primjeri

#include <iostream>
#include <utility>

struct Callable {
    const char* operator()() & { return "lvalue"; }
    const char* operator()() && { return "rvalue"; }
};

template<class F>
void compare(F&& f) {
    const char* direct = f();
    const char* forwarded = std::forward<F>(f)();
    std::cout << direct << ' ' << forwarded << '\n';
}

int main() {
    Callable callable;
    compare(callable);
    compare(Callable{});
}

Rezultat

lvalue lvalue
lvalue rvalue

Svaki redak prikazuje najprije rezultat `f()`, potom rezultat `std::forward<F>(f)()`. Za `callable` oba poziva biraju `&`; za `Callable{}` prvi bira `&`, a drugi `&&`. Objekt se poziva dvaput samo radi usporedbe preopterećenja.

Povezane lekcije

  • C++ · Lekcija 24 · Napredno · Verzija: 3

Izvori