Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Deklarator referencji do l-wartości (&)

Znak `&` w deklaratorze tworzy typ referencji do l-wartości. Dowiedz się, kiedy wiązanie pozwala na zapis, jak działa `const` i kiedy referencja staje się wisząca.

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

Składnia

int x = 2;
int& r = x;
const int& view = x;
const int& temporary = 42;
void update(int& value);
int observe(const int& value);
int& bump(int& value);
using IntRef = int&;
int a[3]{};
int (&row)[3] = a;

W int& r = x; znak & należy do deklaratora. r staje się aliasem obiektu x, a wiązanie nie tworzy jego kopii. Definicja lokalnej zmiennej referencyjnej wymaga inicjalizatora, ale deklaracja referencji w zakresie blokowym z jawnym extern może go pomijać. Po związaniu nie można jej przepiąć: r = y; przypisuje wartość do x, zamiast wiązać r z y.

int& wiąże się z nieconstową l-wartością typu int, ale nie z literałem 42. const int& może związać się zarówno z l-wartością typu int (z const lub bez niego), jak i z obiektem tymczasowym zmaterializowanym z 42. const blokuje zapis przez tę referencję, lecz nie blokuje zmian przez inny alias. Jeśli dostępne są tylko przeciążenia f(int&) i f(const int&), nieconstowa l-wartość typu int wybiera pierwsze, a f(42) drugie.

Parametr T& pozwala zmienić obiekt wywołującego, jeśli T na to pozwala. Wynik T& pozwala wywołującemu uzyskać dostęp do istniejącego obiektu. Gdy iterator zwraca element jako l-wartość, for (const auto& item : items) wiąże się z elementem bez kopiowania go. int (&row)[3] to referencja do całej tablicy trzech elementów int.

Referencja nie jest właścicielem obiektu. Lokalna deklaracja const int& t = 42; przedłuża życie obiektu tymczasowego do końca życia t. Przy zwykłym wywołaniu obiekt tymczasowy związany z parametrem referencyjnym żyje tylko do końca pełnego wyrażenia zawierającego wywołanie. Zwrócenie tej referencji nie przedłuża życia obiektu. Nie zwracaj referencji do lokalnego obiektu automatycznego: odczyt przez wiszącą referencję powoduje niezdefiniowane zachowanie.

W wyrażeniu &x wbudowany operator pobiera adres, a 6 & 3 to bitowe AND. int&& oznacza referencję do r-wartości, [&] określa domyślne przechwytywanie przez referencję w lambdzie, a końcowe & w void f() &; jest kwalifikatorem metody ograniczającym wywołanie do obiektu będącego l-wartością.

Przykłady

#include <iostream>

int& bump(int& value) {
    ++value;
    return value;
}

int observe(const int& value) {
    return value;
}

int main() {
    int value = 2;
    int other = 7;
    auto& ref = bump(value);
    std::cout << "after bump: " << value << '\n';

    ref = other;
    ++other;
    int* ptr = &ref;
    std::cout << "value: " << observe(ref) << ", other: " << other << '\n';
    std::cout << "same object: " << static_cast<int>(ptr == &value)
              << ", mask: " << (6 & 3)
              << ", temporary: " << observe(42) << '\n';
}

Wynik

after bump: 3
value: 7, other: 8
same object: 1, mask: 2, temporary: 42

`bump` zmienia `value` z 2 na 3 i zwraca referencję do tego samego obiektu. `ref = other` zapisuje 7 do `value`; zwiększenie `other` do 8 nie zmienia `value`. Porównanie adresów potwierdza tożsamość obiektu. `6 & 3` daje 2, a `observe(42)` bezpiecznie odczytuje obiekt tymczasowy podczas wywołania.

Powiązane lekcje

  • C++ · Lekcja 1 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 2 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 3 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 5 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 6 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 9 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 10 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 11 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 12 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 13 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 14 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 15 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 16 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 18 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 19 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 21 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 22 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 23 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 25 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 26 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 27 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 28 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 29 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 30 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 31 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 32 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 33 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 34 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 35 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 36 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 38 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 41 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 42 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 43 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 45 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 48 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 49 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 51 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 53 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 54 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 55 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 57 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 59 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 60 · Zaawansowany · Wersja: 3

Źródła