В какой степени С++ - статически типизированный язык?

Раньше я думал, что ответ на этот вопрос "100%", но я недавно указал на пример, который заставляет задуматься дважды. Рассмотрим массив C, объявленный как объект с автоматической продолжительностью хранения:

int main()
{
    int foo[42] = { 0 };
}

Здесь тип foo явно int[42]. Рассмотрим вместо этого этот случай:

int main()
{
    int* foo = new int[rand() % 42];
    delete[] foo;
}

Здесь тип foo равен int*, но как определить тип объекта, созданного выражением new во время компиляции? (Акцент делается на том, что я не говорю о указателе, возвращаемом выражением new, а скорее о объекте массива, созданном выражением new).

Это то, что параграф 5.3.4/1 стандарта С++ 11 указывает на результат выражения new:

[...] Объекты, созданные новым выражением, имеют динамическую продолжительность хранения (3.7.4). [Примечание: время жизни таких сущность не обязательно ограничивается областью, в которой она создана. -end note] Если объект не является массивом object, новое выражение возвращает указатель на созданный объект. Если это массив, новое выражение возвращает указатель на исходный элемент массива.

Раньше я думал, что в С++ тип всех объектов определяется во время компиляции, но приведенный выше пример, похоже, опровергает эту веру. Кроме того, в пункте 1.8/1:

[...] Свойства объекта определяются , когда объект создается. Объект может иметь имя (раздел 3). Объект имеет продолжительность хранения (3.7), которая влияет на его время жизни (3.8). Объект имеет тип (3.9). [...]

Итак, мои вопросы:

Что подразумевается под "свойствами" в последнем цитируемом абзаце? Очевидно, что имя объекта не может считаться чем-то, что определено "когда объект создан" - если "созданный" здесь не означает нечто иное, чем я думаю;
Существуют ли другие примеры объектов, тип которых определяется только во время выполнения?
Насколько корректно говорить, что С++ - это статически типизированный язык? Вернее, что является самым правильным способом классификации С++ в этом отношении?

Было бы здорово, если бы кто-нибудь мог разработать хотя бы один из вышеуказанных пунктов.

EDIT:

Стандарт, похоже, дает понять, что выражение new действительно создает объект массива, а не только несколько объектов, выложенных как массив, как указано некоторыми. В пункте 5.3.4/5 (любезно предоставлено Xeo):

Когда выделенным объектом является массив (т.е. используется синтаксис noptr-new-declarator или идентификатор нового типа или type-id обозначает тип массива), новое выражение дает указатель на исходный элемент (если есть) массива. [Примечание: оба new int и new int[10] имеют тип int*, а тип new int[i][10] - int (*)[10]-end note] Атрибут-specifier-seq в noptr-new-declarator содержит для связанного типа массива.

Ответ 1

Термины "статический тип" и "динамический тип" относятся к выражениям.

статический тип

тип выражения (3.9), полученный в результате анализа программы без рассмотрения семантики выполнения

динамический тип

<glvalue> тип самого производного объекта (1.8), к которому glvalue, обозначенное выражением glvalue, относится к

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

Итак, ваш вопрос:

но как определить тип объекта, созданного новым выражением во время компиляции?

Объекты имеют типы, но они не являются "статическими" или "динамическими" типами, не содержат выражения, которые относятся к объекту. Учитывая выражение, статический тип всегда известен во время компиляции. В отсутствие вывода динамический тип такой же, как у статического типа.

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

template<typename T>
T *create_array(size_t s) {
    switch(s) {
        case 1: return &(*new std::array<T, 1>)[0];
        case 2: return &(*new std::array<T, 2>)[0];
        // ...
    }
}

Здесь мало особых или уникальных. Другая возможность:

struct B { virtual ~B() {}};
struct D : B {};
struct E : B {};

B *create() {
    if (std::bernoulli_distribution(0.5)(std::default_random_engine())) {
        return new D;
    }
    return new E;
}

Или:

void *create() {
    if (std::bernoulli_distribution(0.5)(std::default_random_engine())) {
        return reinterpret_cast<void*>(new int);
    }
    return reinterpret_cast<void*>(new float);
}

Единственное отличие от new int[] заключается в том, что вы не можете видеть в его реализации, чтобы видеть, как он выбирает различные типы объектов для создания.

Ответ 2

Новое выражение не создает объект с типом массива, зависящим от времени выполнения. Он создает много объектов, каждый из которых имеет статический тип int. Количество этих объектов неизвестно статически.

С++ предоставляет два случая (раздел 5.2.8) для динамического типа:

То же, что и статический тип выражения
Когда статический тип является полиморфным, тип времени выполнения самого производного объекта

Ни один из них не дает никакого объекта, созданного типом динамического массива new int[N].

Педантично оценка нового выражения создает бесконечное количество перекрывающихся объектов массива. Из 3.8p2:

[Примечание: время жизни объекта массива начинается, как только будет получено хранилище с надлежащим размером и выравниванием, а его время жизни заканчивается, когда хранилище, которое занимает массив, повторно используется или освобождается. 12.6.2 описывает время жизни базовых и членных подобъектов. - конечная нота]

Итак, если вы хотите поговорить о "объекте массива", созданном new int[5], вы должны указать ему не только тип int[5], но также int[4], int[1], char[5*sizeof(int)] и struct s { int x; }[5].

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

Ответ 3

Раньше я думал, что в С++ тип всех объектов определяется во время компиляции, но приведенный выше пример, похоже, опровергает эту веру.

В примере, который вы цитируете, говорится о продолжительности хранения элемента. С++ распознает три длительности хранения:

Статическая продолжительность хранения - это длительность глобальных и локальных статических переменных.
Автоматическая продолжительность хранения - это продолжительность для локальных переменных "распределенная стек".
Длительность динамического хранения - это продолжительность для динамически распределенной памяти, например, с new или malloc.

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

Раньше я думал, что в С++ тип всех объектов определяется во время компиляции, но приведенный выше пример, похоже, опровергает эту веру.

В вашем примере есть одна переменная, которая имеет тип int*. Нет фактического типа массива для базового массива, который может быть восстановлен любым значимым образом в программе. Не происходит динамического ввода.