Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Wiązania strukturalne: `auto [a, b, c]` a `std::get` i `std::tie`

Deklaruj nazwy elementów krotki za pomocą wiązań strukturalnych. Zobacz, kiedy powstaje kopia, jak odwołać się do oryginału i czym różni się to od `std::get` oraz `std::tie`.

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

Składnia

auto [a, b, c] = t;
auto& [a, b, c] = t;
const auto& [a, b, c] = t;
// Alternative declarations: use different names or separate scopes.
std::get<0>(t);
std::tie(first, std::ignore, last) = t;

auto [a, b, c] = t; to deklaracja wiązań strukturalnych: wprowadza trzy nowe nazwy odpowiadające kolejnym elementom. Wiązania strukturalne są dostępne od C++17; tutaj obowiązują reguły ISO C++23, a obsługa zależy od implementacji.

W C++23 liczba nazw musi odpowiadać liczbie elementów lub rozkładanych składowych; w przeciwnym razie program jest niepoprawny. Dla tablicy wbudowanej obowiązuje kolejność indeksów, dla typu krotkowego — protokół std::tuple_size, std::tuple_element i get, a w pozostałych dopuszczalnych klasach — kolejność deklaracji dostępnych niestatycznych składowych danych. Protokół krotkowy nie sprowadza się do jawnego wywołania std::get: reguły wybierają odpowiednią metodę szablonową get<I>() albo szukają funkcji get<I> wyłącznie przez ADL (wyszukiwanie zależne od argumentu).

auto, & i const dotyczą ukrytej zmiennej. Dla t z przykładu auto kopiuje krotkę, auto& wiąże się z oryginałem, a const auto& pozwala odczytywać jej elementy bez kopiowania, ale nie pozwala ich modyfikować przez te nazwy. Skopiowanie krotki zawierającej referencje nie kopiuje obiektów, do których się one odnoszą. Nie używaj wiązania po zakończeniu życia obiektu, do którego się odnosi.

std::get<I>(t) z <tuple> zwraca referencję do jednego elementu krotki; indeks szablonu zaczyna się od zera i musi być w zakresie. Wariant std::get<T>(t) wymaga, by typ T występował dokładnie raz. std::tie tworzy krotkę referencji do istniejących obiektów; = przypisuje do nich wartości, a std::ignore pomija jedną pozycję. Wiązanie strukturalne deklaruje nazwy i nie pozwala pominąć pozycji w ten sposób.

Przykłady

#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, int, int> t{1, 2, 3};
    auto [a, b, c] = t;
    auto& [x, y, z] = t;

    a = 9;
    x = 7;

    int first = 0;
    int last = 0;
    std::tie(first, std::ignore, last) = t;

    std::cout << "copy: " << a << '\n';
    std::cout << "get: " << std::get<0>(t) << '\n';
    std::cout << "tie: " << first << ' ' << last << '\n';
}

Wynik

copy: 9
get: 7
tie: 7 3

`a = 9` zmienia tylko kopię, a `x = 7` zmienia pierwszy element `t`. Dlatego `std::get<0>(t)` daje `7`, a przypisanie przez `std::tie` zapisuje `7` w `first` i `3` w `last`, pomijając środek.

Powiązane lekcje

  • C++ · Lekcja 32 · Średniozaawansowany · Wersja: 2

Źródła