Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

std::convertible_to — zgodna konwersja niejawna i jawna

std::convertible_to<From, To> z nagłówka <concepts> wymaga konwersji niejawnej i konwersji przez static_cast do To, o zgodnych wynikach. Sama możliwość wykonania jawnego rzutowania nie wystarcza.

Wersja: C++23; repository compiler flag, production runtime not attested

Składnia

template<class From, class To>
concept convertible_to =
    std::is_convertible_v<From, To> &&
    requires { static_cast<To>(std::declval<From>()); };

std::convertible_to<From, To> z nagłówka <concepts> służy do ograniczania szablonów. Jego definicja łączy std::is_convertible_v<From, To> z poprawnością static_cast<To>(std::declval<From>()). Sprawdzany jest typ i kategoria wartości wyrażenia std::declval<From>(), więc kwalifikatory i referencje w From mają znaczenie.

Konwersja niejawna i jawna mają dawać równe wyniki, gdy To jest typem obiektowym lub referencją do obiektu. To wymaganie semantyczne, a nie tylko test poprawności składni: wynik true nie dowodzi, że kompilator sprawdził zachowanie konwersji zdefiniowanych przez użytkownika.

Jeżeli std::add_rvalue_reference_t<From> jest referencją do obiektu, konwersje nie mogą zmieniać obiektu źródłowego, chyba że jest to referencja rvalue do typu bez kwalifikatora const. W tym wyjątku obiekt może pozostać w poprawnym, lecz nieokreślonym stanie. Dla źródła niebędącego referencją do obiektu ten warunek nie ma zastosowania.

W przykładzie short spełnia ograniczenie funkcji as_int. Typ ExplicitOnly pozwala na static_cast<int>, ale jego explicit operator int() nie zapewnia konwersji niejawnej, więc koncept ma wartość false. Koncept nie gwarantuje konwersji bez utraty informacji: zgodność obu sposobów konwersji nie oznacza zachowania całej wartości źródłowej.

Przykłady

#include <concepts>
#include <iostream>

struct ExplicitOnly {
    explicit operator int() const { return 7; }
};

template<class T>
    requires std::convertible_to<T, int>
int as_int(T value) {
    return static_cast<T&&>(value);
}

static_assert(std::convertible_to<short, int>);
static_assert(!std::convertible_to<ExplicitOnly, int>);
static_assert(requires(ExplicitOnly x) { static_cast<int>(x); });

int main() {
    std::cout << as_int(short{7}) << '\n';
    std::cout << static_cast<int>(ExplicitOnly{}) << '\n';
}

Wynik

7
7

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła