Явное преобразование типов

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

[править] Синтаксис

Возвращает значение типа целевой-тип.

[править] Объяснение

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

• lvalue, если целевой-тип это ссылочный тип lvalue или ссылка rvalue на функциональный тип (начиная с C++11);

• иначе prvalue.

[править] Разрешение неоднозначности

[править] Неоднозначное объявление оператора

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

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; // выражение (S::M скрывает ::M), неверное до C++23
    }
};
 
void f(S s)
{
    {
        auto(s)()->N; // выражение, неверное до C++23
        auto(s)()->M; // объявление функции, эквивалентное M s();
    }
    {
        S(s)()->N;    // выражение
        S(s)()->M;    // выражение
    }
}

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

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

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
    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()
}

[править] Неоднозначный идентификатор типа

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

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

typedef struct BB { int C[2]; } *B, C;
 
void foo()
{
    sizeof(B()->C[1]);    // OK, sizeof(выражение)
    sizeof(auto()->C[1]); // ошибка: sizeof функции, возвращающей массив
}

[править] Примечание

[править] Пример

#include <cassert>
#include <iostream>
 
double f = 3.14;
unsigned int n1 = (unsigned int)f; // приведение в стиле C
unsigned int n2 = unsigned(f);     // приведение в функциональном стиле
 
class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // приводит неполный тип к неполному типу
}
 
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); // печатает x:2 y:2, потому что параметр y здесь является
                     // псевдонимом p
    int q{1};
    inc_print(q, auto{q}); // печатает x:2 y:1, auto{q} (C++23) приводит к prvalue,
                           // поэтому параметр y является копией q (а не псевдонимом q)
}
 
// В этом примере приведение в стиле C интерпретируется как
// static_cast, даже если оно будет работать как reinterpret_cast
struct A {};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};
 
int main()
{
    D* d = nullptr;
//  A* a = (A*)d;                   // ошибка времени компиляции
    A* a = reinterpret_cast<A*>(d); // это компилируется
    assert(a == nullptr);
 
    cpp23_decay_copy_demo();
}

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

[править] Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

[править] Ссылки

[править] Смотрите также