Explicit type conversion

Преобразует между типами, используя комбинацию явных и неявных преобразований.

Синтаксис

Явно преобразует любое количество значений в значение целевого типа.

Объяснение

Разрешение неоднозначностей

Неоднозначное объявление

В случае неоднозначности между оператором выражения с функциональной записью приведения типа в качестве крайнего левого подвыражения и оператором объявления, неоднозначность разрешается путём трактовки его как объявления. Это устранение неоднозначности является чисто синтаксическим: оно не учитывает смысл имён, встречающихся в операторе, за исключением того, являются ли они именами типов:

struct M {};
struct L { L(M&); };
M n;
void f()
{
    M(m);    // объявление, эквивалентно M m;
    L(n);    // некорректное объявление, эквивалентно L n;
    L(l)(m); // всё ещё объявление, эквивалентно L l((m));
}

struct M;
struct S
{
    S* operator()();
    int N;
    int M;
    void mem(S s)
    {
        auto(s)()->M; // expression (S::M hides ::M), invalid before C++23
    }
};
void f(S s)
{
    {
        auto(s)()->N; // expression, invalid before C++23
        auto(s)()->M; // function declaration, equivalent to M s();
    }
    {
        S(s)()->N;    // expression
        S(s)()->M;    // expression
    }
}

Неоднозначный параметр функции

Упомянутая выше неоднозначность также может возникать в контексте объявления. В этом контексте выбор стоит между объявлением объекта с функциональным приведением в качестве инициализатора и объявлением, включающим функциональный декларатор с избыточным набором скобок вокруг имени параметра. Разрешение также заключается в том, чтобы рассматривать любую конструкцию, такую как потенциальное объявление параметра, которая может быть объявлением, как объявление:

struct S
{
    S(int);
};
void foo(double a)
{
    S w(int(a)); // объявление функции: имеет параметр `a` типа int
    S x(int());  // объявление функции: имеет безымянный параметр типа int(*)() 
                 // который преобразуется из int()
    // Способы избежать неоднозначности:
    S y((int(a))); // объявление объекта: дополнительные скобки
    S y((int)a);   // объявление объекта: C-style приведение типа
    S z = int(a);  // объявление объекта: нет неоднозначности для этого синтаксиса
}

typedef struct BB { int C[2]; } *B, C;
void foo()
{
    S a(B()->C);    // объявление объекта: B()->C не может объявлять параметр
    S b(auto()->C); // объявление функции: имеет безымянный параметр типа C(*)()
                    // который преобразован из C()
}

Неоднозначный type-id

Неоднозначность может возникнуть из-за схожести между функциональной формой приведения и type-id . Разрешение заключается в том, что любая конструкция, которая может быть type-id в своем синтаксическом контексте, должна рассматриваться как type-id:

// `int()` и `int(unsigned(a))` могут быть разобраны как type-id:
// `int()`            представляет функцию, возвращающую int
//                    и не принимающую аргументов
// `int(unsigned(a))` представляет функцию, возвращающую int
//                    и принимающую аргумент типа unsigned
void foo(signed char a)
{
    sizeof(int());            // type-id (некорректно)
    sizeof(int(a));           // выражение
    sizeof(int(unsigned(a))); // type-id (некорректно)
    (int()) + 1;            // type-id (некорректно)
    (int(a)) + 1;           // выражение
    (int(unsigned(a))) + 1; // type-id (некорректно)
}

typedef struct BB { int C[2]; } *B, C;
void foo()
{
    sizeof(B()->C[1]);    // OK, sizeof(expression)
    sizeof(auto()->C[1]); // error: sizeof of a function returning an array
}

Примечания

Пример

#include <cassert>
#include <iostream>
double f = 3.14;
unsigned int n1 = (unsigned int)f; // C-style cast
unsigned int n2 = unsigned(f);     // function-style cast
class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // casts incomplete type to incomplete type
}
void cpp23_decay_copy_demo()
{
    auto inc_print = [](int& x, const int& y)
    {
        ++x;
        std::cout << "x:" << x << ", y:" << y << '\n';
    };
    int p{1};
    inc_print(p, p); // prints x:2 y:2, because param y here is an alias of p
    int q{1};
    inc_print(q, auto{q}); // prints x:2 y:1, auto{q} (C++23) casts to prvalue,
                           // so the param y is a copy of q (not an alias of q)
}
// In this example, C-style cast is interpreted as static_cast
// even though it would work as reinterpret_cast
struct A {};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};
int main()
{
    D* d = nullptr;
//  A* a = (A*)d;                   // compile-time error
    A* a = reinterpret_cast<A*>(d); // this compiles
    assert(a == nullptr);
    cpp23_decay_copy_demo();
}

x:2 y:2
x:2 y:1

Отчёты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

Смотрите также